oss.c 23.5 KB
Newer Older
1
/*****************************************************************************
2
 * oss.c : OSS /dev/dsp module for vlc
3
 *****************************************************************************
4
 * Copyright (C) 2000-2002 the VideoLAN team
5
 * $Id$
6
7
 *
 * Authors: Michel Kaempf <maxx@via.ecp.fr>
8
 *          Sam Hocevar <sam@zoy.org>
9
 *          Christophe Massiot <massiot@via.ecp.fr>
10
11
12
13
14
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
15
 *
16
17
18
19
20
21
22
 * This program 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
dionoea's avatar
dionoea committed
23
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
24
25
26
27
28
29
30
31
32
33
 *****************************************************************************/

/*****************************************************************************
 * Preamble
 *****************************************************************************/
#include <errno.h>                                                 /* ENOMEM */
#include <fcntl.h>                                       /* open(), O_WRONLY */
#include <sys/ioctl.h>                                            /* ioctl() */
#include <unistd.h>                                      /* write(), close() */

34
35
36
37
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif

38
#include <vlc_common.h>
39
#include <vlc_plugin.h>
40
41
42
43
44

#ifdef HAVE_ALLOCA_H
#   include <alloca.h>
#endif

zorglub's avatar
zorglub committed
45
#include <vlc_aout.h>
46
47
48
49
50
51
52
53
54
55
56

/* SNDCTL_DSP_RESET, SNDCTL_DSP_SETFMT, SNDCTL_DSP_STEREO, SNDCTL_DSP_SPEED,
 * SNDCTL_DSP_GETOSPACE */
#ifdef HAVE_SOUNDCARD_H
#   include <soundcard.h>
#elif defined( HAVE_SYS_SOUNDCARD_H )
#   include <sys/soundcard.h>
#elif defined( HAVE_MACHINE_SOUNDCARD_H )
#   include <machine/soundcard.h>
#endif

57
58
/* Patches for ignorant OSS versions */
#ifndef AFMT_AC3
59
#   define AFMT_AC3     0x00000400        /* Dolby Digital AC3 */
60
61
62
63
64
65
66
67
68
69
#endif

#ifndef AFMT_S16_NE
#   ifdef WORDS_BIGENDIAN
#       define AFMT_S16_NE AFMT_S16_BE
#   else
#       define AFMT_S16_NE AFMT_S16_LE
#   endif
#endif

70
/*****************************************************************************
71
 * aout_sys_t: OSS audio output method descriptor
72
73
 *****************************************************************************
 * This structure is part of the audio output thread descriptor.
74
 * It describes the DSP specific properties of an audio device.
75
76
77
 *****************************************************************************/
struct aout_sys_t
{
gbazin's avatar
   
gbazin committed
78
79
    int i_fd;
    int b_workaround_buggy_driver;
gbazin's avatar
   
gbazin committed
80
81
    int i_fragstotal;
    mtime_t max_buffer_duration;
82
83
};

84
/* This must be a power of 2. */
85
#define FRAME_SIZE 1024
86
#define FRAME_COUNT 32
87

88
89
90
91
92
93
/*****************************************************************************
 * Local prototypes
 *****************************************************************************/
static int  Open         ( vlc_object_t * );
static void Close        ( vlc_object_t * );

94
static void Play         ( aout_instance_t * );
95
static int  OSSThread    ( aout_instance_t * );
96

gbazin's avatar
   
gbazin committed
97
98
static mtime_t BufferDuration( aout_instance_t * p_aout );

99
100
101
/*****************************************************************************
 * Module descriptor
 *****************************************************************************/
Christophe Massiot's avatar
Christophe Massiot committed
102
#define BUGGY_TEXT N_("Try to work around buggy OSS drivers")
gbazin's avatar
   
gbazin committed
103
104
105
106
107
#define BUGGY_LONGTEXT N_( \
    "Some buggy OSS drivers just don't like when their internal buffers " \
    "are completely filled (the sound gets heavily hashed). If you have one " \
    "of these drivers, then you need to enable this option." )

108
vlc_module_begin();
109
    set_shortname( "OSS" );
110
    set_description( N_("UNIX OSS audio output") );
gbazin's avatar
   
gbazin committed
111

zorglub's avatar
zorglub committed
112
113
    set_category( CAT_AUDIO );
    set_subcategory( SUBCAT_AUDIO_AOUT );
114
    add_file( "dspdev", "/dev/dsp", aout_FindAndRestart,
115
116
              N_("OSS DSP device"), NULL, false );
    add_bool( "oss-buggy", 0, NULL, BUGGY_TEXT, BUGGY_LONGTEXT, true );
gbazin's avatar
   
gbazin committed
117

gbazin's avatar
   
gbazin committed
118
    set_capability( "audio output", 100 );
119
    add_shortcut( "oss" );
120
121
122
    set_callbacks( Open, Close );
vlc_module_end();

123
124
125
126
127
128
/*****************************************************************************
 * Probe: probe the audio device for available formats and channels
 *****************************************************************************/
static void Probe( aout_instance_t * p_aout )
{
    struct aout_sys_t * p_sys = p_aout->output.p_sys;
gbazin's avatar
   
gbazin committed
129
    vlc_value_t val, text;
130
131
    int i_format, i_nb_channels;

gbazin's avatar
   
gbazin committed
132
    var_Create( p_aout, "audio-device", VLC_VAR_INTEGER | VLC_VAR_HASCHOICE );
133
    text.psz_string = _("Audio Device");
gbazin's avatar
   
gbazin committed
134
    var_Change( p_aout, "audio-device", VLC_VAR_SETTEXT, &text, NULL );
135

gbazin's avatar
   
gbazin committed
136
    /* Test for multi-channel. */
137
138
139
140
141
142
#ifdef SNDCTL_DSP_GETCHANNELMASK
    if ( aout_FormatNbChannels( &p_aout->output.output ) > 2 )
    {
        /* Check that the device supports this. */

        int i_chanmask;
gbazin's avatar
   
gbazin committed
143
144
145
146
147
148
149
150
151
152
153

        /* Reset all. */
        i_format = AFMT_S16_NE;
        if( ioctl( p_sys->i_fd, SNDCTL_DSP_RESET, NULL ) < 0 ||
            ioctl( p_sys->i_fd, SNDCTL_DSP_SETFMT, &i_format ) < 0 )
        {
            msg_Err( p_aout, "cannot reset OSS audio device" );
            var_Destroy( p_aout, "audio-device" );
            return;
        }

154
155
156
157
158
        if ( ioctl( p_sys->i_fd, SNDCTL_DSP_GETCHANNELMASK,
                    &i_chanmask ) == 0 )
        {
            if ( !(i_chanmask & DSP_BIND_FRONT) )
            {
159
                msg_Err( p_aout, "no front channels! (%x)",
160
161
162
163
164
165
166
167
168
169
                         i_chanmask );
                return;
            }

            if ( (i_chanmask & (DSP_BIND_SURR | DSP_BIND_CENTER_LFE))
                  && (p_aout->output.output.i_physical_channels ==
                       (AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER
                         | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT
                         | AOUT_CHAN_LFE)) )
            {
gbazin's avatar
   
gbazin committed
170
                val.i_int = AOUT_VAR_5_1;
171
                text.psz_string = "5.1";
gbazin's avatar
   
gbazin committed
172
173
                var_Change( p_aout, "audio-device",
                            VLC_VAR_ADDCHOICE, &val, &text );
174
175
176
177
178
179
180
            }

            if ( (i_chanmask & DSP_BIND_SURR)
                  && (p_aout->output.output.i_physical_channels &
                       (AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT
                         | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT)) )
            {
gbazin's avatar
   
gbazin committed
181
182
183
184
                val.i_int = AOUT_VAR_2F2R;
                text.psz_string = N_("2 Front 2 Rear");
                var_Change( p_aout, "audio-device",
                            VLC_VAR_ADDCHOICE, &val, &text );
185
186
187
188
189
            }
        }
    }
#endif

gbazin's avatar
   
gbazin committed
190
191
192
193
194
195
196
197
198
199
    /* Reset all. */
    i_format = AFMT_S16_NE;
    if( ioctl( p_sys->i_fd, SNDCTL_DSP_RESET, NULL ) < 0 ||
        ioctl( p_sys->i_fd, SNDCTL_DSP_SETFMT, &i_format ) < 0 )
    {
        msg_Err( p_aout, "cannot reset OSS audio device" );
        var_Destroy( p_aout, "audio-device" );
        return;
    }

200
201
202
203
204
    /* Test for stereo. */
    i_nb_channels = 2;
    if( ioctl( p_sys->i_fd, SNDCTL_DSP_CHANNELS, &i_nb_channels ) >= 0
         && i_nb_channels == 2 )
    {
gbazin's avatar
   
gbazin committed
205
206
207
        val.i_int = AOUT_VAR_STEREO;
        text.psz_string = N_("Stereo");
        var_Change( p_aout, "audio-device", VLC_VAR_ADDCHOICE, &val, &text );
208
209
210
211
212
213
214
215
216
217
218
219
220
221
    }

    /* Reset all. */
    i_format = AFMT_S16_NE;
    if( ioctl( p_sys->i_fd, SNDCTL_DSP_RESET, NULL ) < 0 ||
        ioctl( p_sys->i_fd, SNDCTL_DSP_SETFMT, &i_format ) < 0 )
    {
        msg_Err( p_aout, "cannot reset OSS audio device" );
        var_Destroy( p_aout, "audio-device" );
        return;
    }

    /* Test for mono. */
    i_nb_channels = 1;
222
    if( ioctl( p_sys->i_fd, SNDCTL_DSP_CHANNELS, &i_nb_channels ) >= 0
223
224
         && i_nb_channels == 1 )
    {
gbazin's avatar
   
gbazin committed
225
226
227
        val.i_int = AOUT_VAR_MONO;
        text.psz_string = N_("Mono");
        var_Change( p_aout, "audio-device", VLC_VAR_ADDCHOICE, &val, &text );
228
229
230
231
        if ( p_aout->output.output.i_physical_channels == AOUT_CHAN_CENTER )
        {
            var_Set( p_aout, "audio-device", val );
        }
232
    }
233

gbazin's avatar
   
gbazin committed
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
    if( ioctl( p_sys->i_fd, SNDCTL_DSP_RESET, NULL ) < 0 )
    {
        msg_Err( p_aout, "cannot reset OSS audio device" );
        var_Destroy( p_aout, "audio-device" );
        return;
    }

    /* Test for spdif. */
    if ( AOUT_FMT_NON_LINEAR( &p_aout->output.output ) )
    {
        i_format = AFMT_AC3;

        if( ioctl( p_sys->i_fd, SNDCTL_DSP_SETFMT, &i_format ) >= 0
             && i_format == AFMT_AC3 )
        {
gbazin's avatar
   
gbazin committed
249
250
251
252
            val.i_int = AOUT_VAR_SPDIF;
            text.psz_string = N_("A/52 over S/PDIF");
            var_Change( p_aout, "audio-device",
                        VLC_VAR_ADDCHOICE, &val, &text );
gbazin's avatar
   
gbazin committed
253
254
255
            if( config_GetInt( p_aout, "spdif" ) )
                var_Set( p_aout, "audio-device", val );
        }
256
257
        else if( config_GetInt( p_aout, "spdif" ) )
        {
258
            msg_Warn( p_aout, "S/PDIF not supported by card" );
259
        }
260
    }
261
262
263

    var_AddCallback( p_aout, "audio-device", aout_ChannelsRestart,
                     NULL );
264
265
}

266
/*****************************************************************************
267
 * Open: open the audio device (the digital sound processor)
268
 *****************************************************************************
269
 * This function opens the DSP as a usual non-blocking write-only file, and
270
271
272
273
 * modifies the p_aout->p_sys->i_fd with the file's descriptor.
 *****************************************************************************/
static int Open( vlc_object_t *p_this )
{
274
275
276
    aout_instance_t * p_aout = (aout_instance_t *)p_this;
    struct aout_sys_t * p_sys;
    char * psz_device;
277
    vlc_value_t val;
278
279

    /* Allocate structure */
280
281
    p_aout->output.p_sys = p_sys = malloc( sizeof( aout_sys_t ) );
    if( p_sys == NULL )
282
        return VLC_ENOMEM;
283

284
    /* Get device name */
285
    if( (psz_device = config_GetPsz( p_aout, "dspdev" )) == NULL )
286
    {
287
        msg_Err( p_aout, "no audio device specified (maybe /dev/dsp?)" );
288
        free( p_sys );
289
        return VLC_EGENERIC;
290
291
    }

292
293
294
295
296
    /* Open the sound device in non-blocking mode, because ALSA's OSS
     * emulation and some broken OSS drivers would make a blocking call
     * wait forever until the device is available. Since this breaks the
     * OSS spec, we immediately put it back to blocking mode if the
     * operation was successful. */
297
    p_sys->i_fd = open( psz_device, O_WRONLY | O_NDELAY );
gbazin's avatar
   
gbazin committed
298
    if( p_sys->i_fd < 0 )
299
    {
300
        msg_Err( p_aout, "cannot open audio device (%s)", psz_device );
301
        free( p_sys );
302
        return VLC_EGENERIC;
303
    }
304
305
306
307
308

    /* if the opening was ok, put the device back in blocking mode */
    fcntl( p_sys->i_fd, F_SETFL,
            fcntl( p_sys->i_fd, F_GETFL ) &~ FNDELAY );

Christophe Massiot's avatar
Christophe Massiot committed
309
    free( psz_device );
310

311
    p_aout->output.pf_play = Play;
312

gbazin's avatar
   
gbazin committed
313
    if ( var_Type( p_aout, "audio-device" ) == 0 )
314
315
316
317
318
319
320
321
322
323
324
    {
        Probe( p_aout );
    }

    if ( var_Get( p_aout, "audio-device", &val ) < 0 )
    {
        /* Probe() has failed. */
        free( p_sys );
        return VLC_EGENERIC;
    }

gbazin's avatar
   
gbazin committed
325
    if ( val.i_int == AOUT_VAR_SPDIF )
326
327
328
    {
        p_aout->output.output.i_format = VLC_FOURCC('s','p','d','i');
    }
gbazin's avatar
   
gbazin committed
329
    else if ( val.i_int == AOUT_VAR_5_1 )
330
331
332
333
    {
        p_aout->output.output.i_format = AOUT_FMT_S16_NE;
        p_aout->output.output.i_physical_channels
            = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER
334
               | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT
335
336
               | AOUT_CHAN_LFE;
    }
gbazin's avatar
   
gbazin committed
337
    else if ( val.i_int == AOUT_VAR_2F2R )
338
339
340
341
    {
        p_aout->output.output.i_format = AOUT_FMT_S16_NE;
        p_aout->output.output.i_physical_channels
            = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT
342
               | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT;
343
    }
gbazin's avatar
   
gbazin committed
344
    else if ( val.i_int == AOUT_VAR_STEREO )
345
346
347
348
349
    {
        p_aout->output.output.i_format = AOUT_FMT_S16_NE;
        p_aout->output.output.i_physical_channels
            = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT;
    }
gbazin's avatar
   
gbazin committed
350
    else if ( val.i_int == AOUT_VAR_MONO )
351
352
353
354
    {
        p_aout->output.output.i_format = AOUT_FMT_S16_NE;
        p_aout->output.output.i_physical_channels = AOUT_CHAN_CENTER;
    }
355
356
357
    else
    {
        /* This should not happen ! */
gbazin's avatar
   
gbazin committed
358
        msg_Err( p_aout, "internal: can't find audio-device (%i)", val.i_int );
359
360
361
        free( p_sys );
        return VLC_EGENERIC;
    }
362

363
    val.b_bool = true;
364
365
    var_Set( p_aout, "intf-change", val );

366
    /* Reset the DSP device */
367
    if( ioctl( p_sys->i_fd, SNDCTL_DSP_RESET, NULL ) < 0 )
368
    {
369
        msg_Err( p_aout, "cannot reset OSS audio device" );
370
371
        close( p_sys->i_fd );
        free( p_sys );
372
373
        return VLC_EGENERIC;
    }
374

375
    /* Set the output format */
376
    if ( AOUT_FMT_NON_LINEAR( &p_aout->output.output ) )
377
    {
378
        int i_format = AFMT_AC3;
379

380
381
382
        if( ioctl( p_sys->i_fd, SNDCTL_DSP_SETFMT, &i_format ) < 0
             || i_format != AFMT_AC3 )
        {
383
384
385
386
            msg_Err( p_aout, "cannot reset OSS audio device" );
            close( p_sys->i_fd );
            free( p_sys );
            return VLC_EGENERIC;
387
388
        }

389
390
391
392
393
394
        p_aout->output.output.i_format = VLC_FOURCC('s','p','d','i');
        p_aout->output.i_nb_samples = A52_FRAME_NB;
        p_aout->output.output.i_bytes_per_frame = AOUT_SPDIF_SIZE;
        p_aout->output.output.i_frame_length = A52_FRAME_NB;

        aout_VolumeNoneInit( p_aout );
395
    }
396
397

    if ( !AOUT_FMT_NON_LINEAR( &p_aout->output.output ) )
398
    {
399
400
401
402
        unsigned int i_format = AFMT_S16_NE;
        unsigned int i_frame_size, i_fragments;
        unsigned int i_rate;
        unsigned int i_nb_channels;
gbazin's avatar
   
gbazin committed
403
        audio_buf_info audio_buf;
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441

        if( ioctl( p_sys->i_fd, SNDCTL_DSP_SETFMT, &i_format ) < 0 )
        {
            msg_Err( p_aout, "cannot set audio output format" );
            close( p_sys->i_fd );
            free( p_sys );
            return VLC_EGENERIC;
        }

        switch ( i_format )
        {
        case AFMT_U8:
            p_aout->output.output.i_format = VLC_FOURCC('u','8',' ',' ');
            break;
        case AFMT_S8:
            p_aout->output.output.i_format = VLC_FOURCC('s','8',' ',' ');
            break;
        case AFMT_U16_LE:
            p_aout->output.output.i_format = VLC_FOURCC('u','1','6','l');
            break;
        case AFMT_S16_LE:
            p_aout->output.output.i_format = VLC_FOURCC('s','1','6','l');
            break;
        case AFMT_U16_BE:
            p_aout->output.output.i_format = VLC_FOURCC('u','1','6','b');
            break;
        case AFMT_S16_BE:
            p_aout->output.output.i_format = VLC_FOURCC('s','1','6','b');
            break;
        default:
            msg_Err( p_aout, "OSS fell back to an unknown format (%d)",
                     i_format );
            close( p_sys->i_fd );
            free( p_sys );
            return VLC_EGENERIC;
        }

        i_nb_channels = aout_FormatNbChannels( &p_aout->output.output );
442

443
        /* Set the number of channels */
444
445
        if( ioctl( p_sys->i_fd, SNDCTL_DSP_CHANNELS, &i_nb_channels ) < 0 ||
            i_nb_channels != aout_FormatNbChannels( &p_aout->output.output ) )
446
        {
447
            msg_Err( p_aout, "cannot set number of audio channels (%s)",
448
                     aout_FormatPrintChannels( &p_aout->output.output) );
449
450
            close( p_sys->i_fd );
            free( p_sys );
451
            return VLC_EGENERIC;
452
453
454
455
456
457
458
459
        }

        /* Set the output rate */
        i_rate = p_aout->output.output.i_rate;
        if( ioctl( p_sys->i_fd, SNDCTL_DSP_SPEED, &i_rate ) < 0 )
        {
            msg_Err( p_aout, "cannot set audio output rate (%i)",
                             p_aout->output.output.i_rate );
460
461
            close( p_sys->i_fd );
            free( p_sys );
462
            return VLC_EGENERIC;
463
464
465
466
467
468
        }

        if( i_rate != p_aout->output.output.i_rate )
        {
            p_aout->output.output.i_rate = i_rate;
        }
gbazin's avatar
   
gbazin committed
469
470
471
472
473
474

        /* Set the fragment size */
        aout_FormatPrepare( &p_aout->output.output );

        /* i_fragment = xxxxyyyy where: xxxx        is fragtotal
         *                              1 << yyyy   is fragsize */
475
476
477
        i_frame_size = ((uint64_t)p_aout->output.output.i_bytes_per_frame * p_aout->output.output.i_rate * 65536) / (48000 * 2 * 2) / FRAME_COUNT;
        i_fragments = 4;
        while( i_fragments < 12 && (1U << i_fragments) < i_frame_size )
gbazin's avatar
   
gbazin committed
478
479
480
481
482
483
484
485
486
487
488
        {
            ++i_fragments;
        }
        i_fragments |= FRAME_COUNT << 16;
        if( ioctl( p_sys->i_fd, SNDCTL_DSP_SETFRAGMENT, &i_fragments ) < 0 )
        {
            msg_Warn( p_aout, "cannot set fragment size (%.8x)", i_fragments );
        }

        if( ioctl( p_sys->i_fd, SNDCTL_DSP_GETOSPACE, &audio_buf ) < 0 )
        {
489
            msg_Err( p_aout, "cannot get fragment size" );
gbazin's avatar
   
gbazin committed
490
491
492
493
            close( p_sys->i_fd );
            free( p_sys );
            return VLC_EGENERIC;
        }
gbazin's avatar
   
gbazin committed
494
        else
gbazin's avatar
   
gbazin committed
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
        {
            /* Number of fragments actually allocated */
            p_aout->output.p_sys->i_fragstotal = audio_buf.fragstotal;

            /* Maximum duration the soundcard's buffer can hold */
            p_aout->output.p_sys->max_buffer_duration =
                (mtime_t)audio_buf.fragstotal * audio_buf.fragsize * 1000000
                / p_aout->output.output.i_bytes_per_frame
                / p_aout->output.output.i_rate
                * p_aout->output.output.i_frame_length;

            p_aout->output.i_nb_samples = audio_buf.fragsize /
                p_aout->output.output.i_bytes_per_frame;
        }

        aout_VolumeSoftInit( p_aout );
511
512
    }

513
514
515
    p_aout->output.p_sys->b_workaround_buggy_driver =
        config_GetInt( p_aout, "oss-buggy" );

Christophe Massiot's avatar
Christophe Massiot committed
516
517
    /* Create OSS thread and wait for its readiness. */
    if( vlc_thread_create( p_aout, "aout", OSSThread,
518
                           VLC_THREAD_PRIORITY_OUTPUT, false ) )
Christophe Massiot's avatar
Christophe Massiot committed
519
    {
520
        msg_Err( p_aout, "cannot create OSS thread (%m)" );
Christophe Massiot's avatar
Christophe Massiot committed
521
522
523
524
        close( p_sys->i_fd );
        free( p_sys );
        return VLC_ETHREAD;
    }
525

526
    return VLC_SUCCESS;
527
528
529
}

/*****************************************************************************
Christophe Massiot's avatar
Christophe Massiot committed
530
 * Play: nothing to do
531
 *****************************************************************************/
532
static void Play( aout_instance_t *p_aout )
533
{
534
    VLC_UNUSED(p_aout);
535
536
537
}

/*****************************************************************************
538
 * Close: close the DSP audio device
539
540
541
542
543
544
 *****************************************************************************/
static void Close( vlc_object_t * p_this )
{
    aout_instance_t *p_aout = (aout_instance_t *)p_this;
    struct aout_sys_t * p_sys = p_aout->output.p_sys;

545
    vlc_object_kill( p_aout );
546
    vlc_thread_join( p_aout );
547
    p_aout->b_die = false;
548

549
    ioctl( p_sys->i_fd, SNDCTL_DSP_RESET, NULL );
550
    close( p_sys->i_fd );
551

552
    free( p_sys );
553
554
555
}

/*****************************************************************************
556
 * BufferDuration: buffer status query
557
 *****************************************************************************
558
 * This function returns the duration in microseconds of the current buffer.
559
 *****************************************************************************/
560
static mtime_t BufferDuration( aout_instance_t * p_aout )
561
{
562
563
    struct aout_sys_t * p_sys = p_aout->output.p_sys;
    audio_buf_info audio_buf;
564
    int i_bytes;
565

566
567
568
569
570
    /* Fill the audio_buf_info structure:
     * - fragstotal: total number of fragments allocated
     * - fragsize: size of a fragment in bytes
     * - bytes: available space in bytes (includes partially used fragments)
     * Note! 'bytes' could be more than fragments*fragsize */
571
    ioctl( p_sys->i_fd, SNDCTL_DSP_GETOSPACE, &audio_buf );
572

573
574
575
576
577
578
579
580
    /* calculate number of available fragments (not partially used ones) */
    i_bytes = (audio_buf.fragstotal * audio_buf.fragsize) - audio_buf.bytes;

    /* Return the fragment duration */
    return (mtime_t)i_bytes * 1000000
            / p_aout->output.output.i_bytes_per_frame
            / p_aout->output.output.i_rate
            * p_aout->output.output.i_frame_length;
581
582
583
}

/*****************************************************************************
584
 * OSSThread: asynchronous thread used to DMA the data to the device
585
 *****************************************************************************/
586
static int OSSThread( aout_instance_t * p_aout )
587
{
588
    struct aout_sys_t * p_sys = p_aout->output.p_sys;
589
    mtime_t next_date = 0;
590

591
    while ( !p_aout->b_die )
592
    {
593
        aout_buffer_t * p_buffer = NULL;
Christophe Massiot's avatar
Christophe Massiot committed
594
        int i_tmp, i_size;
595
        uint8_t * p_bytes;
596

597
        if ( p_aout->output.output.i_format != VLC_FOURCC('s','p','d','i') )
Christophe Massiot's avatar
Christophe Massiot committed
598
        {
599
            mtime_t buffered = BufferDuration( p_aout );
600

gbazin's avatar
   
gbazin committed
601
            if( p_aout->output.p_sys->b_workaround_buggy_driver )
602
            {
gbazin's avatar
   
gbazin committed
603
#define i_fragstotal p_aout->output.p_sys->i_fragstotal
gbazin's avatar
   
gbazin committed
604
                /* Wait a bit - we don't want our buffer to be full */
gbazin's avatar
   
gbazin committed
605
606
                if( buffered > (p_aout->output.p_sys->max_buffer_duration
                                / i_fragstotal * (i_fragstotal - 1)) )
gbazin's avatar
   
gbazin committed
607
                {
gbazin's avatar
   
gbazin committed
608
609
                    msleep((p_aout->output.p_sys->max_buffer_duration
                                / i_fragstotal ));
gbazin's avatar
   
gbazin committed
610
611
                    buffered = BufferDuration( p_aout );
                }
gbazin's avatar
   
gbazin committed
612
#undef i_fragstotal
613
            }
614

gbazin's avatar
   
gbazin committed
615
616
            /* Next buffer will be played at mdate() + buffered */
            p_buffer = aout_OutputNextBuffer( p_aout, mdate() + buffered,
617
                                              false );
gbazin's avatar
   
gbazin committed
618
619
620
621

            if( p_buffer == NULL &&
                buffered > ( p_aout->output.p_sys->max_buffer_duration
                             / p_aout->output.p_sys->i_fragstotal ) )
622
            {
gbazin's avatar
   
gbazin committed
623
624
625
626
627
628
                /* If we have at least a fragment full, then we can wait a
                 * little and retry to get a new audio buffer instead of
                 * playing a blank sample */
                msleep( ( p_aout->output.p_sys->max_buffer_duration
                          / p_aout->output.p_sys->i_fragstotal / 2 ) );
                continue;
629
            }
630
631
632
        }
        else
        {
633
634
635
636
637
638
639
640
641
642
643
644
645
646
            /* emu10k1 driver does not report Buffer Duration correctly in
             * passthrough mode so we have to cheat */
            if( !next_date )
            {
                next_date = mdate();
            }
            else
            {
                mtime_t delay = next_date - mdate();
                if( delay > AOUT_PTS_TOLERANCE )
                {
                    msleep( delay / 2 );
                }
            }
647

648
            while( !p_aout->b_die && ! ( p_buffer =
649
                aout_OutputNextBuffer( p_aout, next_date, true ) ) )
650
            {
651
                msleep( 1000 );
652
653
                next_date = mdate();
            }
654
        }
655
656
657
658

        if ( p_buffer != NULL )
        {
            p_bytes = p_buffer->p_buffer;
659
            i_size = p_buffer->i_nb_bytes;
660
661
662
            /* This is theoretical ... we'll see next iteration whether
             * we're drifting */
            next_date += p_buffer->end_date - p_buffer->start_date;
663
664
665
        }
        else
        {
666
667
            i_size = FRAME_SIZE / p_aout->output.output.i_frame_length
                      * p_aout->output.output.i_bytes_per_frame;
668
            p_bytes = malloc( i_size );
Christophe Massiot's avatar
Christophe Massiot committed
669
            memset( p_bytes, 0, i_size );
670
            next_date = 0;
671
672
        }

Christophe Massiot's avatar
Christophe Massiot committed
673
        i_tmp = write( p_sys->i_fd, p_bytes, i_size );
674
675
676

        if( i_tmp < 0 )
        {
Rafaël Carré's avatar
Rafaël Carré committed
677
            msg_Err( p_aout, "write failed (%m)" );
678
679
680
681
682
683
        }

        if ( p_buffer != NULL )
        {
            aout_BufferFree( p_buffer );
        }
684
685
686
687
        else
        {
            free( p_bytes );
        }
688
    }
689

690
    return VLC_SUCCESS;
691
}