summaryrefslogtreecommitdiffstats
path: root/audio/audio_buffer.c
blob: 53563f90c6e96bb84bf49180f34c83a35dcbd095 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
/*
 * This file is part of mpv.
 *
 * mpv 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.
 *
 * mpv 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 mpv.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <stddef.h>
#include <limits.h>
#include <assert.h>

#include "mpvcore/mp_common.h"

#include "audio_buffer.h"
#include "audio.h"
#include "format.h"

struct mp_audio_buffer {
    struct mp_audio *buffer;
};

struct mp_audio_buffer *mp_audio_buffer_create(void *talloc_ctx)
{
    struct mp_audio_buffer *ab = talloc(talloc_ctx, struct mp_audio_buffer);
    *ab = (struct mp_audio_buffer) {
        .buffer = talloc_zero(ab, struct mp_audio),
    };
    return ab;
}

// Reinitialize the buffer, set a new format, drop old data.
// The audio data in fmt is not used, only the format.
void mp_audio_buffer_reinit(struct mp_audio_buffer *ab, struct mp_audio *fmt)
{
    mp_audio_copy_config(ab->buffer, fmt);
    mp_audio_realloc(ab->buffer, 1);
    ab->buffer->samples = 0;
}

void mp_audio_buffer_reinit_fmt(struct mp_audio_buffer *ab, int format,
                                const struct mp_chmap *channels, int srate)
{
    struct mp_audio mpa = {0};
    mp_audio_set_format(&mpa, format);
    mp_audio_set_channels(&mpa, channels);
    mpa.rate = srate;
    mp_audio_buffer_reinit(ab, &mpa);
}

void mp_audio_buffer_get_format(struct mp_audio_buffer *ab,
                                struct mp_audio *out_fmt)
{
    *out_fmt = (struct mp_audio){0};
    mp_audio_copy_config(out_fmt, ab->buffer);
}

// Make the total size of the internal buffer at least this number of samples.
void mp_audio_buffer_preallocate_min(struct mp_audio_buffer *ab, int samples)
{
    mp_audio_realloc_min(ab->buffer, samples);
}

// Get number of samples that can be written without forcing a resize of the
// internal buffer.
int mp_audio_buffer_get_write_available(struct mp_audio_buffer *ab)
{
    return mp_audio_get_allocated_size(ab->buffer) - ab->buffer->samples;
}

// Get a pointer to the end of the buffer (where writing would append). If the
// internal buffer is too small for the given number of samples, it's resized.
// After writing to the buffer, mp_audio_buffer_finish_write() has to be used
// to make the written data part of the readable buffer.
void mp_audio_buffer_get_write_buffer(struct mp_audio_buffer *ab, int samples,
                                      struct mp_audio *out_buffer)
{
    assert(samples >= 0);
    mp_audio_realloc_min(ab->buffer, ab->buffer->samples + samples);
    *out_buffer = *ab->buffer;
    out_buffer->samples = ab->buffer->samples + samples;
    mp_audio_skip_samples(out_buffer, ab->buffer->samples);
}

void mp_audio_buffer_finish_write(struct mp_audio_buffer *ab, int samples)
{
    assert(samples >= 0 && samples <= mp_audio_buffer_get_write_available(ab));
    ab->buffer->samples += samples;
}

// Append data to the end of the buffer.
// If the buffer is not large enough, it is transparently resized.
// For now always copies the data.
void mp_audio_buffer_append(struct mp_audio_buffer *ab, struct mp_audio *mpa)
{
    int offset = ab->buffer->samples;
    ab->buffer->samples += mpa->samples;
    mp_audio_realloc_min(ab->buffer, ab->buffer->samples);
    mp_audio_copy(ab->buffer, offset, mpa, 0, mpa->samples);
}

// Prepend silence to the start of the buffer.
void mp_audio_buffer_prepend_silence(struct mp_audio_buffer *ab, int samples)
{
    assert(samples >= 0);
    int oldlen = ab->buffer->samples;
    ab->buffer->samples += samples;
    mp_audio_realloc_min(ab->buffer, ab->buffer->samples);
    mp_audio_copy(ab->buffer, samples, ab->buffer, 0, oldlen);
    mp_audio_fill_silence(ab->buffer, 0, samples);
}

// Get the start of the current readable buffer.
void mp_audio_buffer_peek(struct mp_audio_buffer *ab, struct mp_audio *out_mpa)
{
    *out_mpa = *ab->buffer;
}

// Skip leading samples. (Used with mp_audio_buffer_peek() to read data.)
void mp_audio_buffer_skip(struct mp_audio_buffer *ab, int samples)
{
    assert(samples >= 0 && samples <= ab->buffer->samples);
    mp_audio_copy(ab->buffer, 0, ab->buffer, samples,
                  ab->buffer->samples - samples);
    ab->buffer->samples -= samples;
}

void mp_audio_buffer_clear(struct mp_audio_buffer *ab)
{
    ab->buffer->samples = 0;
}

// Return number of buffered audio samples
int mp_audio_buffer_samples(struct mp_audio_buffer *ab)
{
    return ab->buffer->samples;
}

// Return amount of buffered audio in seconds.
double mp_audio_buffer_seconds(struct mp_audio_buffer *ab)
{
    return ab->buffer->samples / (double)ab->buffer->rate;
}