Revision 4b7c0418

b/audio/audio_pt_int.c
6 6 
#include "audio_int.h"
7 7 
#include "audio_pt_int.h"
8 8 

  		





  
  9
  
    
#include <signal.h>


  		





  
  10
  
    

  		





  9
  11
  
    
static void logerr (struct audio_pt *pt, int err, const char *fmt, ...)


  		





  10
  12
  
    
{


  		





  11
  13
  
    
    va_list ap;


  		





  ......




  23
  25
  
    
{


  		





  24
  26
  
    
    int err, err2;


  		





  25
  27
  
    
    const char *efunc;


  		





  
  28
  
    
    sigset_t set, old_set;


  		





  26
  29
  
    

  		





  27
  30
  
    
    p->drv = drv;


  		





  28
  31
  
    

  		





  
  32
  
    
    err = sigfillset (&set);


  		





  
  33
  
    
    if (err) {


  		





  
  34
  
    
        logerr (p, errno, "%s(%s): sigfillset failed", cap, AUDIO_FUNC);


  		





  
  35
  
    
        return -1;


  		





  
  36
  
    
    }


  		





  
  37
  
    

  		





  29
  38
  
    
    err = pthread_mutex_init (&p->mutex, NULL);


  		





  30
  39
  
    
    if (err) {


  		





  31
  40
  
    
        efunc = "pthread_mutex_init";


  		





  ......




  38
  47
  
    
        goto err1;


  		





  39
  48
  
    
    }


  		





  40
  49
  
    

  		





  
  50
  
    
    err = pthread_sigmask (SIG_BLOCK, &set, &old_set);


  		





  
  51
  
    
    if (err) {


  		





  
  52
  
    
        efunc = "pthread_sigmask";


  		





  
  53
  
    
        goto err2;


  		





  
  54
  
    
    }


  		





  
  55
  
    

  		





  41
  56
  
    
    err = pthread_create (&p->thread, NULL, func, opaque);


  		





  
  57
  
    

  		





  
  58
  
    
    err2 = pthread_sigmask (SIG_SETMASK, &old_set, NULL);


  		





  
  59
  
    
    if (err2) {


  		





  
  60
  
    
        logerr (p, err2, "%s(%s): pthread_sigmask (restore) failed",


  		





  
  61
  
    
                cap, AUDIO_FUNC);


  		





  
  62
  
    
        /* We have failed to restore original signal mask, all bets are off,


  		





  
  63
  
    
           so terminate the process */


  		





  
  64
  
    
        exit (EXIT_FAILURE);


  		





  
  65
  
    
    }


  		





  
  66
  
    

  		





  42
  67
  
    
    if (err) {


  		





  43
  68
  
    
        efunc = "pthread_create";


  		





  44
  69
  
    
        goto err2;


  		












  

    
      b/audio/esdaudio.c
    
  






  24
  24
  
    
#include <esd.h>


  		





  25
  25
  
    
#include "qemu-common.h"


  		





  26
  26
  
    
#include "audio.h"


  		





  27
  
  
    
#include <signal.h>


  		





  28
  27
  
    

  		





  29
  28
  
    
#define AUDIO_CAP "esd"


  		





  30
  29
  
    
#include "audio_int.h"


  		





  ......




  190
  189
  
    
    ESDVoiceOut *esd = (ESDVoiceOut *) hw;


  		





  191
  190
  
    
    struct audsettings obt_as = *as;


  		





  192
  191
  
    
    int esdfmt = ESD_STREAM | ESD_PLAY;


  		





  193
  
  
    
    int err;


  		





  194
  
  
    
    sigset_t set, old_set;


  		





  195
  
  
    

  		





  196
  
  
    
    sigfillset (&set);


  		





  197
  192
  
    

  		





  198
  193
  
    
    esdfmt |= (as->nchannels == 2) ? ESD_STEREO : ESD_MONO;


  		





  199
  194
  
    
    switch (as->fmt) {


  		





  ......




  231
  226
  
    
        return -1;


  		





  232
  227
  
    
    }


  		





  233
  228
  
    

  		





  234
  
  
    
    esd->fd = -1;


  		





  235
  
  
    
    err = pthread_sigmask (SIG_BLOCK, &set, &old_set);


  		





  236
  
  
    
    if (err) {


  		





  237
  
  
    
        qesd_logerr (err, "pthread_sigmask failed\n");


  		





  238
  
  
    
        goto fail1;


  		





  239
  
  
    
    }


  		





  240
  
  
    

  		





  241
  229
  
    
    esd->fd = esd_play_stream (esdfmt, as->freq, conf.dac_host, NULL);


  		





  242
  230
  
    
    if (esd->fd < 0) {


  		





  243
  231
  
    
        qesd_logerr (errno, "esd_play_stream failed\n");


  		





  244
  
  
    
        goto fail2;


  		





  
  232
  
    
        goto fail1;


  		





  245
  233
  
    
    }


  		





  246
  234
  
    

  		





  247
  235
  
    
    if (audio_pt_init (&esd->pt, qesd_thread_out, esd, AUDIO_CAP, AUDIO_FUNC)) {


  		





  248
  
  
    
        goto fail3;


  		





  249
  
  
    
    }


  		





  250
  
  
    

  		





  251
  
  
    
    err = pthread_sigmask (SIG_SETMASK, &old_set, NULL);


  		





  252
  
  
    
    if (err) {


  		





  253
  
  
    
        qesd_logerr (err, "pthread_sigmask(restore) failed\n");


  		





  
  236
  
    
        goto fail2;


  		





  254
  237
  
    
    }


  		





  255
  238
  
    

  		





  256
  239
  
    
    return 0;


  		





  257
  240
  
    

  		





  258
  
  
    
 fail3:


  		





  
  241
  
    
 fail2:


  		





  259
  242
  
    
    if (close (esd->fd)) {


  		





  260
  243
  
    
        qesd_logerr (errno, "%s: close on esd socket(%d) failed\n",


  		





  261
  244
  
    
                     AUDIO_FUNC, esd->fd);


  		





  262
  245
  
    
    }


  		





  263
  246
  
    
    esd->fd = -1;


  		





  264
  247
  
    

  		





  265
  
  
    
 fail2:


  		





  266
  
  
    
    err = pthread_sigmask (SIG_SETMASK, &old_set, NULL);


  		





  267
  
  
    
    if (err) {


  		





  268
  
  
    
        qesd_logerr (err, "pthread_sigmask(restore) failed\n");


  		





  269
  
  
    
    }


  		





  270
  
  
    

  		





  271
  248
  
    
 fail1:


  		





  272
  249
  
    
    qemu_free (esd->pcm_buf);


  		





  273
  250
  
    
    esd->pcm_buf = NULL;


  		





  ......




  423
  400
  
    
    ESDVoiceIn *esd = (ESDVoiceIn *) hw;


  		





  424
  401
  
    
    struct audsettings obt_as = *as;


  		





  425
  402
  
    
    int esdfmt = ESD_STREAM | ESD_RECORD;


  		





  426
  
  
    
    int err;


  		





  427
  
  
    
    sigset_t set, old_set;


  		





  428
  
  
    

  		





  429
  
  
    
    sigfillset (&set);


  		





  430
  403
  
    

  		





  431
  404
  
    
    esdfmt |= (as->nchannels == 2) ? ESD_STEREO : ESD_MONO;


  		





  432
  405
  
    
    switch (as->fmt) {


  		





  ......




  461
  434
  
    
        return -1;


  		





  462
  435
  
    
    }


  		





  463
  436
  
    

  		





  464
  
  
    
    esd->fd = -1;


  		





  465
  
  
    

  		





  466
  
  
    
    err = pthread_sigmask (SIG_BLOCK, &set, &old_set);


  		





  467
  
  
    
    if (err) {


  		





  468
  
  
    
        qesd_logerr (err, "pthread_sigmask failed\n");


  		





  469
  
  
    
        goto fail1;


  		





  470
  
  
    
    }


  		





  471
  
  
    

  		





  472
  437
  
    
    esd->fd = esd_record_stream (esdfmt, as->freq, conf.adc_host, NULL);


  		





  473
  438
  
    
    if (esd->fd < 0) {


  		





  474
  439
  
    
        qesd_logerr (errno, "esd_record_stream failed\n");


  		





  475
  
  
    
        goto fail2;


  		





  
  440
  
    
        goto fail1;


  		





  476
  441
  
    
    }


  		





  477
  442
  
    

  		





  478
  443
  
    
    if (audio_pt_init (&esd->pt, qesd_thread_in, esd, AUDIO_CAP, AUDIO_FUNC)) {


  		





  479
  
  
    
        goto fail3;


  		





  480
  
  
    
    }


  		





  481
  
  
    

  		





  482
  
  
    
    err = pthread_sigmask (SIG_SETMASK, &old_set, NULL);


  		





  483
  
  
    
    if (err) {


  		





  484
  
  
    
        qesd_logerr (err, "pthread_sigmask(restore) failed\n");


  		





  
  444
  
    
        goto fail2;


  		





  485
  445
  
    
    }


  		





  486
  446
  
    

  		





  487
  447
  
    
    return 0;


  		





  488
  448
  
    

  		





  489
  
  
    
 fail3:


  		





  
  449
  
    
 fail2:


  		





  490
  450
  
    
    if (close (esd->fd)) {


  		





  491
  451
  
    
        qesd_logerr (errno, "%s: close on esd socket(%d) failed\n",


  		





  492
  452
  
    
                     AUDIO_FUNC, esd->fd);


  		





  493
  453
  
    
    }


  		





  494
  454
  
    
    esd->fd = -1;


  		





  495
  455
  
    

  		





  496
  
  
    
 fail2:


  		





  497
  
  
    
    err = pthread_sigmask (SIG_SETMASK, &old_set, NULL);


  		





  498
  
  
    
    if (err) {


  		





  499
  
  
    
        qesd_logerr (err, "pthread_sigmask(restore) failed\n");


  		





  500
  
  
    
    }


  		





  501
  
  
    

  		





  502
  456
  
    
 fail1:


  		





  503
  457
  
    
    qemu_free (esd->pcm_buf);


  		





  504
  458
  
    
    esd->pcm_buf = NULL;


  		












Also available in:
  Unified diff