Attachment 135231 Details for Bug 103103 – Second version of application, which should reproduce a problem

Second version of application, which should reproduce a problem

check_play_after_silence.c (text/x-csrc), 9.44 KB, created by mkid.dev on 2017-11-03 17:42:01 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: mkid.dev

Created: 2017-11-03 17:42:01 UTC

Size: 9.44 KB

patch

obsolete

>/* gcc -g -O0 -o check_play_after_silence check_play_after_silence.c $(pkg-config --cflags --libs libpulse) -lm */
>#include <stdio.h>
>#include <string.h>
>#include <math.h>
>#include <sys/types.h>
>#include <sys/stat.h>
>#include <unistd.h>
>#include <time.h>
>#include <inttypes.h>
>#include <signal.h>
>
>#include <pulse/pulseaudio.h>
>
>#define SILENCE_DURATION 30 /* s */
>#define FS (44100)
>#define POINTS_PER_CYCLE 32
>#define CHANNELS_COUNT 2
>#define SAMPLES_COUNT (CHANNELS_COUNT * POINTS_PER_CYCLE * 10) 
>#define FRAMES_COUNT ( SAMPLES_COUNT / CHANNELS_COUNT )
>
>#define us_per_sample (PA_USEC_PER_SEC / (double) FS)
>#define ALIGN_TO_FRAME_BOUNDARY(_N_) ( ((_N_) + frame_size - 1) / frame_size * frame_size )
>
>static int16_t sampledata[SAMPLES_COUNT];
>static size_t frame_size;
>static volatile int silence = 0;
>static pa_usec_t app_start_time = 0;
>
>static pa_usec_t get_app_time(void)
>{
>    return pa_rtclock_now() - app_start_time;
>}
>
>static void put_timing_info(pa_stream * s, const char *context) {
>    printf("%zu> timing info on %s: " , get_app_time(), context);
>
>    const pa_timing_info *info = pa_stream_get_timing_info(s);
>    if (info == NULL) {
>        printf("no data\n");
>        return;
>    }
>    if (info->write_index_corrupt || info->read_index_corrupt) {
>        printf("at least on index is corrupted\n");
>        return;
>    }
>    struct timeval tv_now;
>    gettimeofday(&tv_now, NULL);
>    uint64_t a, b;
>    a = tv_now.tv_sec * PA_USEC_PER_SEC + tv_now.tv_usec;
>    b = info->timestamp.tv_sec * PA_USEC_PER_SEC + info->timestamp.tv_usec;
>
>    printf("took %" PRIu64 " us ago, write_index %" PRId64 " B, read_index %" PRId64 " B, sink_usec %zu\n",
>            a - b, info->write_index, info->read_index, info->sink_usec);
>}
>
>static void write_samples(pa_stream * s, size_t length) {
>    static pa_usec_t first_time = 0;
>    static int64_t offset = 0LL;
>    static int sampleoffs = 0;
>    size_t original_length;
>
>    length = ALIGN_TO_FRAME_BOUNDARY(length);
>    original_length = length;
>
>    /* Calculation of absolute offset based on elapsed time */
>    pa_usec_t now = pa_rtclock_now();
>    if (first_time == 0) {
>        first_time = now;
>    } else {
>        pa_usec_t time_delta_us = now - first_time;
>        int64_t offset_based_on_time =(int64_t) floor(time_delta_us / us_per_sample * frame_size);
>        int64_t delta = offset_based_on_time - offset;
>        if (delta > 0) {
>            offset = ALIGN_TO_FRAME_BOUNDARY(offset + delta);
>            printf("\n\n\n%zu> GAP %f s, delta %" PRId64 " B, new offset %" PRId64 "\n\n\n", get_app_time(),
>               time_delta_us / (float) PA_USEC_PER_SEC, delta, offset);
>        } else {
>            printf("%zu> in time, to underrun %" PRId64 " B, to write %zu B\n", get_app_time(), labs(delta), length);
>        }
>    }
>
>    /* Write samples from the precalculated buffer */
>    printf("%zu> want to write %zu B at offset %zu B\n", get_app_time(), length, offset);
>    while (length > 0) {
>        if (sampleoffs * frame_size == sizeof(sampledata))
>            sampleoffs = 0;
>        size_t to_end = sizeof(sampledata) - sampleoffs * frame_size;    /* bytes */
>        if (to_end > length)
>            to_end = length;
>
>        int error = pa_stream_write(s, &sampledata[sampleoffs * CHANNELS_COUNT], to_end, NULL, offset,
>                            PA_SEEK_ABSOLUTE);
>        if (error != PA_OK) {
>            printf("pa_stream_write error %s, original_length %zu, length %zu, to_end %zu, offset %" PRId64 "\n", 
>                    pa_strerror(error), original_length, length, to_end, offset);
>            exit(__LINE__);
>        }
>
>        sampleoffs += to_end / frame_size;
>        offset += to_end;
>        length -= to_end;
>    }
>    printf("%zu> all written\n", get_app_time());
>}
>
>static void pa_state_cb(pa_context * c, void *userdata) {
>    pa_threaded_mainloop *mainloop = (pa_threaded_mainloop *) userdata;
>    pa_context_state_t state;
>    state = pa_context_get_state(c);
>    switch (state) {
>        /* These are just here for reference */
>    case PA_CONTEXT_UNCONNECTED:
>    case PA_CONTEXT_CONNECTING:
>    case PA_CONTEXT_AUTHORIZING:
>    case PA_CONTEXT_SETTING_NAME:
>    default:
>        break;
>    case PA_CONTEXT_FAILED:
>        printf("state failed %s\n", pa_strerror(pa_context_errno(c)));
>        exit(__LINE__);
>        break;
>    case PA_CONTEXT_TERMINATED:
>        printf("state terminated\n");
>        exit(__LINE__);
>        break;
>    case PA_CONTEXT_READY:
>        pa_threaded_mainloop_signal(mainloop, 0);
>        break;
>    }
>}
>
>static void stream_request_cb(pa_stream * s, size_t length, void *userdata) {
>    printf("%zu> request: %zu B\n", get_app_time(), length);
>    pa_threaded_mainloop_signal((pa_threaded_mainloop *) userdata, 0);
>}
>
>static void stream_latency_update_cb(pa_stream * s, void *userdata) {
>    put_timing_info(s, "latency update");
>}
>
>static void stream_notify_underflow_cb(pa_stream * s, void *userdata) {
>    printf("%zu> notify: underflow at %" PRId64 "\n", get_app_time(), pa_stream_get_underflow_index(s));
>    put_timing_info(s, "underflow");
>    pa_threaded_mainloop_signal((pa_threaded_mainloop *) userdata, 0);    
>}
>
>static void stream_notify_overflow_cb(pa_stream * s, void *userdata) {
>    printf("%zu> notify: overflow\n", get_app_time());
>    put_timing_info(s, "overflow");
>    pa_threaded_mainloop_signal((pa_threaded_mainloop *) userdata, 0);    
>}
>
>static void stream_generic_notify_cb(pa_stream * s, void *userdata) {
>    printf("%zu> notify: %s\n", get_app_time(), (const char *) userdata);
>    put_timing_info(s, (const char *) userdata);
>}
>
>static void stream_started_cb(pa_stream * s, void *userdata) {
>    printf("%zu> notify: started\n", get_app_time());
>    put_timing_info(s, "started");
>    pa_threaded_mainloop_signal((pa_threaded_mainloop *) userdata, 0);
>}
>
>static void stream_event_cb(pa_stream * s, const char *name, pa_proplist *pl, void *userdata) {
>    printf("%zu> event\n", get_app_time());
>    put_timing_info(s, "event");
>}
>
>void handler (int signum) {
>    printf("\n\n\n%zu> Stop providing data for: %d s\n\n\n", get_app_time(), SILENCE_DURATION);
>    silence = 1;
>}
>
>int main(int argc, char *argv[]) {
>    pa_threaded_mainloop *pa_ml;
>    pa_mainloop_api *pa_mlapi;
>    pa_context *pa_ctx;
>    pa_stream *playstream;
>
>    app_start_time = pa_rtclock_now();    
>    
>    /* Create some data to play */
>    for (unsigned int i = 0; i < FRAMES_COUNT; i++)
>        sampledata[i * CHANNELS_COUNT] = sampledata[i * CHANNELS_COUNT + 1] =  32000.0 * cos(FS / POINTS_PER_CYCLE * 2 * M_PI * i / FS);
>
>    /* Create a mainloop API and connection to the default server */
>    pa_ml = pa_threaded_mainloop_new();
>    pa_threaded_mainloop_start(pa_ml);
>    pa_threaded_mainloop_lock(pa_ml);
>
>    pa_mlapi = pa_threaded_mainloop_get_api(pa_ml);
>    pa_ctx = pa_context_new(pa_mlapi, "Bug 103103 test application");
>    pa_context_connect(pa_ctx, NULL, 0, NULL);
>    pa_context_set_state_callback(pa_ctx, pa_state_cb, pa_ml);
>    pa_threaded_mainloop_wait(pa_ml);
>
>    pa_sample_spec ss = {.rate = FS, .channels = CHANNELS_COUNT, .format = PA_SAMPLE_S16LE};
>    playstream = pa_stream_new(pa_ctx, "Playback", &ss, NULL);
>    if (!playstream) {
>        printf("pa_stream_new failed\n");
>        exit(__LINE__);
>    }
>    frame_size = pa_frame_size(&ss);
>    
>    pa_stream_set_started_callback(playstream, stream_started_cb, pa_ml);
>    pa_stream_set_write_callback(playstream, stream_request_cb, pa_ml);
>    pa_stream_set_underflow_callback(playstream, stream_notify_underflow_cb, pa_ml);
>    pa_stream_set_overflow_callback(playstream, stream_notify_overflow_cb, pa_ml);
>    pa_stream_set_latency_update_callback(playstream, stream_latency_update_cb, NULL);
>    pa_stream_set_moved_callback(playstream, stream_generic_notify_cb, "moved");
>    pa_stream_set_suspended_callback(playstream, stream_generic_notify_cb, "suspended");
>    pa_stream_set_event_callback(playstream, stream_event_cb, NULL);
>
>    pa_buffer_attr bufattr = {.maxlength = 122880 * 4, .tlength = 38400 * 4, .prebuf = 0, .minreq = 1920, .fragsize = 0};
>    int r = pa_stream_connect_playback(playstream, NULL, &bufattr,
>                                   PA_STREAM_INTERPOLATE_TIMING
>                                   | PA_STREAM_ADJUST_LATENCY
>                                   | PA_STREAM_AUTO_TIMING_UPDATE, NULL,
>                                   NULL);
>    if (r < 0) {
>        printf("pa_stream_connect_playback failed\n");
>        exit(__LINE__);
>    }
>    
>    signal(SIGALRM, handler);
>    alarm(3);
>    
>    /* Wait for stream start */
>    pa_threaded_mainloop_wait(pa_ml);
>
>    while (1) {
>        size_t writable;
>
>        while ((writable = pa_stream_writable_size(playstream)) == 0) {
>            printf("%zu> no space left, the mainloop has to wait...\n", get_app_time());
>            pa_threaded_mainloop_wait(pa_ml);
>            printf("%zu> then mainloop is run again\n", get_app_time());
>        }
>        
>        pa_threaded_mainloop_unlock(pa_ml);
>  
>        if (silence == 1) {
>            sleep(SILENCE_DURATION);
>            printf("\n\n\n%zu> Start providing data\n\n\n", get_app_time());
>        }
>
>        pa_threaded_mainloop_lock(pa_ml);
>        
>        if (silence == 0) {
>            if (writable == (size_t) -1LL) {
>                printf("%zu> error: %s\n", get_app_time(), pa_strerror(pa_context_errno(pa_ctx)));
>                exit(__LINE__);
>            } else {
>                write_samples(playstream, writable);
>            }
>        } else
>            silence = 0;
>    }
>
>    pa_context_disconnect(pa_ctx);
>    pa_context_unref(pa_ctx);
>    pa_threaded_mainloop_free(pa_ml);
>    return 0;
>}

Actions: View

Attachments on bug 103103: 135110 | 135111 | 135112 | 135231

Use of freedesktop.org services, including Bugzilla, is subject to our Code of Conduct. How we collect and use information is described in our Privacy Policy.