PulseAudio:バッファ

• バッファアンダーフロー
  再生中に、バッファが空になった。
  書き込みよりも、再生の方が追いついてしまった状態。
• バッファオーバーフロー
  バッファの最大サイズを超えて、データが書き込まれた。

void pa_stream_set_underflow_callback(pa_stream *p, pa_stream_notify_cb_t cb, void *userdata);
void pa_stream_set_overflow_callback(pa_stream *p, pa_stream_notify_cb_t cb, void *userdata);

//コールバック関数
typedef void (*pa_stream_notify_cb_t)(pa_stream *p, void *userdata);

$ cc -o 13-overflow 13-overflow.c util.c -lpulse

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <pulse/pulseaudio.h>
#include "util.h"

#define SAMPRATE  48000
#define BUFMAXLEN SAMPRATE

PulseData *pulse;

//オーバーフロー

static void _cb_overflow(pa_stream *p,void *userdata)
{
    printf("* overflow\n");
}

//バッファのすべてのデータを書き込み

static void _write_data(void *buf,int sendsize)
{
    pa_stream *strm = pulse->stream;
    size_t size;
    void *writebuf;

    pa_threaded_mainloop_lock(pulse->mainloop);

    while(sendsize)
    {
        size = pa_stream_writable_size(strm);
        printf("writable: %d\n", (int)size);

        size = sendsize;
        if(size > BUFMAXLEN) size = BUFMAXLEN;
        
        if(pa_stream_begin_write(strm, &writebuf, &size)) break;

        memcpy(writebuf, buf, size);

        printf("* write: %d\n", (int)size);

        pa_stream_write(strm, writebuf, size, NULL, 0, PA_SEEK_RELATIVE);

        //100 ms 待つ (イベント処理のため)
        pa_threaded_mainloop_unlock(pulse->mainloop);
        pa_msleep(100);
        pa_threaded_mainloop_lock(pulse->mainloop);

        buf += size;
        sendsize -= size;
    }

    pa_threaded_mainloop_unlock(pulse->mainloop);
}

//バッファ情報のセット

static pa_operation *_set_buffer_attr(PulseData *p,void *data)
{
    struct pa_buffer_attr attr;

    attr.maxlength = BUFMAXLEN;   //0.5秒
    attr.tlength = BUFMAXLEN / 4; //1/8秒
    attr.prebuf = (uint32_t)-1;
    attr.minreq = (uint32_t)-1;
    attr.fragsize = (uint32_t)-1;

    return pa_stream_set_buffer_attr(pulse->stream, &attr, pulse_stream_success_callback_signal, p);
}

//バッファ情報表示

static void _put_buffer_attr(void)
{
    const pa_buffer_attr *attr;

    attr = pa_stream_get_buffer_attr(pulse->stream);

    printf("maxlength: %u\n", attr->maxlength);
    printf("tlength: %u\n", attr->tlength);
    printf("prebuf: %u\n", attr->prebuf);
    printf("minreq: %u\n----\n", attr->minreq);
}

int main(void)
{
    uint8_t *buf,*dst;
    int bufsize,i;
    double freq[4] = {261.626, 293.665, 329.628, 349.228};

    pulse = pulse_connect(0);
    if(!pulse) return 1;

    if(pulse_create_stream_play(pulse, PA_SAMPLE_S16LE, SAMPRATE, 1))
        pulse_enderr(pulse);

    pulse_wait_operation(pulse, _set_buffer_attr, NULL);

    _put_buffer_attr();

    //コールバック

    pa_threaded_mainloop_lock(pulse->mainloop);
    pa_stream_set_overflow_callback(pulse->stream, _cb_overflow, NULL);
    pa_threaded_mainloop_unlock(pulse->mainloop);

    //書き込み

    bufsize = 2 * SAMPRATE;

    buf = dst = (uint8_t *)malloc(bufsize);

    for(i = 0; i < 4; i++)
    {
        pulse_write_buf_sawtooth(dst, bufsize / 4, SAMPRATE, freq[i]);
        dst += bufsize / 4;
    }
    
    _write_data(buf, bufsize);

    free(buf);

    //

    pulse_wait_drain(pulse);

    pulse_free(pulse);

    return 0;
}

# stream connected
maxlength: 48000
tlength: 12000
prebuf: 10082
minreq: 1920
----
writable: 24000
* write: 48000
writable: 0
* write: 48000
* overflow