mirror of
https://gitlab.freedesktop.org/pipewire/pipewire
synced 2024-10-15 12:22:47 +00:00
buffer: remove buffer id
The buffer id is not needed/used, we use the index of the buffer in the buffer array when configuring the port.
This commit is contained in:
parent
e918f9f77c
commit
5b7ddb0105
|
@ -1 +1 @@
|
|||
Subproject commit a4593a0d96757cb2362f9c02abdcd55f7206967d
|
||||
Subproject commit 25b8a7919f021e5b6354febe37e320adc8b9a297
|
|
@ -1 +1 @@
|
|||
Subproject commit 89fb73a949d4ceb1c4d41269e29ffade8bc3e386
|
||||
Subproject commit bebfcf0190c507103d998744fdddd9eac624d526
|
|
@ -89,7 +89,7 @@ static inline int spa_buffer_alloc_fill_info(struct spa_buffer_alloc_info *info,
|
|||
|
||||
static inline struct spa_buffer *
|
||||
spa_buffer_alloc_layout(struct spa_buffer_alloc_info *info,
|
||||
void *skel_mem, void *data_mem, uint32_t id)
|
||||
void *skel_mem, void *data_mem)
|
||||
{
|
||||
struct spa_buffer *b = skel_mem;
|
||||
size_t size;
|
||||
|
@ -97,7 +97,6 @@ spa_buffer_alloc_layout(struct spa_buffer_alloc_info *info,
|
|||
void **dp, *skel, *data;
|
||||
struct spa_chunk *cp;
|
||||
|
||||
b->id = id;
|
||||
b->n_metas = info->n_metas;
|
||||
b->metas = SPA_MEMBER(b, sizeof(struct spa_buffer), struct spa_meta);
|
||||
b->n_datas = info->n_datas;
|
||||
|
@ -154,9 +153,9 @@ spa_buffer_alloc_layout_array(struct spa_buffer_alloc_info *info,
|
|||
uint32_t i;
|
||||
size_t data_size = info->data_size + info->meta_size + info->chunk_size;
|
||||
for (i = 0; i < n_buffers; i++) {
|
||||
buffers[i] = spa_buffer_alloc_layout(info, skel_mem, data_mem, i);
|
||||
skel_mem = SPA_MEMBER(skel_mem, info->skel_size, void);
|
||||
data_mem = SPA_MEMBER(data_mem, data_size, void);
|
||||
buffers[i] = spa_buffer_alloc_layout(info, skel_mem, data_mem);
|
||||
skel_mem = SPA_MEMBER(skel_mem, info->skel_size, void);
|
||||
data_mem = SPA_MEMBER(data_mem, data_size, void);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
|
@ -71,11 +71,10 @@ struct spa_data {
|
|||
|
||||
/** A Buffer */
|
||||
struct spa_buffer {
|
||||
uint32_t id; /**< the id of this buffer */
|
||||
struct spa_meta *metas; /**< array of metadata */
|
||||
uint32_t n_metas; /**< number of metadata */
|
||||
struct spa_data *datas; /**< array of data members */
|
||||
uint32_t n_datas; /**< number of data members */
|
||||
struct spa_meta *metas; /**< array of metadata */
|
||||
struct spa_data *datas; /**< array of data members */
|
||||
};
|
||||
|
||||
/** Find metadata in a buffer */
|
||||
|
|
|
@ -53,8 +53,8 @@ enum spa_meta_type {
|
|||
*/
|
||||
struct spa_meta {
|
||||
uint32_t type; /**< metadata type, one of enum spa_meta_type */
|
||||
void *data; /**< pointer to metadata */
|
||||
uint32_t size; /**< size of metadata */
|
||||
void *data; /**< pointer to metadata */
|
||||
};
|
||||
|
||||
#define spa_meta_first(m) ((m)->data)
|
||||
|
|
|
@ -563,6 +563,7 @@ impl_node_port_use_buffers(struct spa_node *node,
|
|||
uint32_t type;
|
||||
|
||||
b->buf = buffers[i];
|
||||
b->id = i;
|
||||
b->flags = BUFFER_FLAG_OUT;
|
||||
|
||||
b->h = spa_buffer_find_meta_data(b->buf, SPA_META_Header, sizeof(*b->h));
|
||||
|
|
|
@ -562,6 +562,7 @@ impl_node_port_use_buffers(struct spa_node *node,
|
|||
struct spa_data *d = buffers[i]->datas;
|
||||
|
||||
b->buf = buffers[i];
|
||||
b->id = i;
|
||||
b->flags = 0;
|
||||
|
||||
b->h = spa_buffer_find_meta_data(b->buf, SPA_META_Header, sizeof(*b->h));
|
||||
|
@ -579,7 +580,6 @@ impl_node_port_use_buffers(struct spa_node *node,
|
|||
return 0;
|
||||
}
|
||||
|
||||
|
||||
static int
|
||||
impl_node_port_alloc_buffers(struct spa_node *node,
|
||||
enum spa_direction direction,
|
||||
|
@ -687,9 +687,9 @@ static int impl_node_process(struct spa_node *node)
|
|||
b = spa_list_first(&this->ready, struct buffer, link);
|
||||
spa_list_remove(&b->link);
|
||||
|
||||
spa_log_trace(this->log, NAME " %p: dequeue buffer %d", node, b->buf->id);
|
||||
spa_log_trace(this->log, NAME " %p: dequeue buffer %d", node, b->id);
|
||||
|
||||
io->buffer_id = b->buf->id;
|
||||
io->buffer_id = b->id;
|
||||
io->status = SPA_STATUS_HAVE_BUFFER;
|
||||
|
||||
return SPA_STATUS_HAVE_BUFFER;
|
||||
|
|
|
@ -716,9 +716,9 @@ again:
|
|||
if (state->ready_offset >= size) {
|
||||
spa_list_remove(&b->link);
|
||||
SPA_FLAG_SET(b->flags, BUFFER_FLAG_OUT);
|
||||
state->io->buffer_id = b->buf->id;
|
||||
spa_log_trace(state->log, "alsa-util %p: reuse buffer %u", state, b->buf->id);
|
||||
state->callbacks->reuse_buffer(state->callbacks_data, 0, b->buf->id);
|
||||
state->io->buffer_id = b->id;
|
||||
spa_log_trace(state->log, "alsa-util %p: reuse buffer %u", state, b->id);
|
||||
state->callbacks->reuse_buffer(state->callbacks_data, 0, b->id);
|
||||
state->ready_offset = 0;
|
||||
}
|
||||
written += n_frames;
|
||||
|
|
|
@ -57,10 +57,11 @@ struct props {
|
|||
#define MAX_BUFFERS 32
|
||||
|
||||
struct buffer {
|
||||
uint32_t id;
|
||||
uint32_t flags;
|
||||
struct spa_buffer *buf;
|
||||
struct spa_meta_header *h;
|
||||
#define BUFFER_FLAG_OUT (1<<0)
|
||||
uint32_t flags;
|
||||
struct spa_list link;
|
||||
};
|
||||
|
||||
|
|
|
@ -61,9 +61,10 @@ static void props_reset(struct props *props)
|
|||
}
|
||||
|
||||
struct buffer {
|
||||
struct spa_list link;
|
||||
uint32_t id;
|
||||
#define BUFFER_FLAG_OUT (1 << 0)
|
||||
uint32_t flags;
|
||||
struct spa_list link;
|
||||
struct spa_buffer *outbuf;
|
||||
struct spa_meta_header *h;
|
||||
};
|
||||
|
@ -959,6 +960,7 @@ impl_node_port_use_buffers(struct spa_node *node,
|
|||
struct spa_data *d = buffers[i]->datas;
|
||||
|
||||
b = &port->buffers[i];
|
||||
b->id = i;
|
||||
b->flags = 0;
|
||||
b->outbuf = buffers[i];
|
||||
b->h = spa_buffer_find_meta_data(buffers[i], SPA_META_Header, sizeof(*b->h));
|
||||
|
@ -1165,7 +1167,7 @@ static int impl_node_process(struct spa_node *node)
|
|||
}
|
||||
|
||||
outio->status = SPA_STATUS_HAVE_BUFFER;
|
||||
outio->buffer_id = dbuf->outbuf->id;
|
||||
outio->buffer_id = dbuf->id;
|
||||
|
||||
inio->status = SPA_STATUS_NEED_BUFFER;
|
||||
|
||||
|
|
|
@ -63,9 +63,10 @@ static void props_reset(struct props *props)
|
|||
}
|
||||
|
||||
struct buffer {
|
||||
struct spa_list link;
|
||||
uint32_t id;
|
||||
#define BUFFER_FLAG_OUT (1 << 0)
|
||||
uint32_t flags;
|
||||
struct spa_list link;
|
||||
struct spa_buffer *outbuf;
|
||||
struct spa_meta_header *h;
|
||||
};
|
||||
|
@ -676,6 +677,7 @@ impl_node_port_use_buffers(struct spa_node *node,
|
|||
struct spa_data *d = buffers[i]->datas;
|
||||
|
||||
b = &port->buffers[i];
|
||||
b->id = i;
|
||||
b->flags = 0;
|
||||
b->outbuf = buffers[i];
|
||||
b->h = spa_buffer_find_meta_data(buffers[i], SPA_META_Header, sizeof(*b->h));
|
||||
|
@ -882,7 +884,7 @@ static int impl_node_process(struct spa_node *node)
|
|||
res |= SPA_STATUS_NEED_BUFFER;
|
||||
|
||||
outio->status = SPA_STATUS_HAVE_BUFFER;
|
||||
outio->buffer_id = outb->id;
|
||||
outio->buffer_id = outbuf->id;
|
||||
res |= SPA_STATUS_HAVE_BUFFER;
|
||||
|
||||
return res;
|
||||
|
|
|
@ -47,6 +47,7 @@
|
|||
#define MAX_PORTS 128
|
||||
|
||||
struct buffer {
|
||||
uint32_t id;
|
||||
#define BUFFER_FLAG_QUEUED (1<<0)
|
||||
uint32_t flags;
|
||||
struct spa_list link;
|
||||
|
@ -740,7 +741,7 @@ static struct buffer *dequeue_buffer(struct impl *this, struct port *port)
|
|||
spa_list_remove(&b->link);
|
||||
SPA_FLAG_UNSET(b->flags, BUFFER_FLAG_QUEUED);
|
||||
spa_log_trace(this->log, NAME " %p: dequeue buffer %d on port %d %u",
|
||||
this, b->buf->id, port->id, b->flags);
|
||||
this, b->id, port->id, b->flags);
|
||||
|
||||
return b;
|
||||
}
|
||||
|
@ -776,8 +777,9 @@ impl_node_port_use_buffers(struct spa_node *node,
|
|||
struct spa_data *d = buffers[i]->datas;
|
||||
|
||||
b = &port->buffers[i];
|
||||
b->buf = buffers[i];
|
||||
b->id = i;
|
||||
b->flags = 0;
|
||||
b->buf = buffers[i];
|
||||
|
||||
if (!((d[0].type == SPA_DATA_MemPtr ||
|
||||
d[0].type == SPA_DATA_MemFd ||
|
||||
|
@ -895,7 +897,7 @@ static inline int get_out_buffer(struct impl *this, struct port *port, struct bu
|
|||
return -EPIPE;
|
||||
|
||||
io->status = SPA_STATUS_HAVE_BUFFER;
|
||||
io->buffer_id = (*buf)->buf->id;
|
||||
io->buffer_id = (*buf)->id;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
|
@ -59,9 +59,10 @@ static void props_reset(struct props *props)
|
|||
}
|
||||
|
||||
struct buffer {
|
||||
struct spa_list link;
|
||||
uint32_t id;
|
||||
#define BUFFER_FLAG_OUT (1 << 0)
|
||||
uint32_t flags;
|
||||
struct spa_list link;
|
||||
struct spa_buffer *outbuf;
|
||||
struct spa_meta_header *h;
|
||||
};
|
||||
|
@ -607,6 +608,7 @@ impl_node_port_use_buffers(struct spa_node *node,
|
|||
struct spa_data *d = buffers[i]->datas;
|
||||
|
||||
b = &port->buffers[i];
|
||||
b->id = i;
|
||||
b->flags = 0;
|
||||
b->outbuf = buffers[i];
|
||||
b->h = spa_buffer_find_meta_data(buffers[i], SPA_META_Header, sizeof(*b->h));
|
||||
|
@ -838,7 +840,7 @@ static int impl_node_process(struct spa_node *node)
|
|||
outport->offset += out_len * sizeof(float);
|
||||
if (outport->offset > 0 && outport->offset >= maxsize) {
|
||||
outio->status = SPA_STATUS_HAVE_BUFFER;
|
||||
outio->buffer_id = dbuf->outbuf->id;
|
||||
outio->buffer_id = dbuf->id;
|
||||
dequeue_buffer(this, dbuf);
|
||||
outport->offset = 0;
|
||||
SPA_FLAG_SET(res, SPA_STATUS_HAVE_BUFFER);
|
||||
|
|
|
@ -48,6 +48,7 @@
|
|||
#define MAX_PORTS 128
|
||||
|
||||
struct buffer {
|
||||
uint32_t id;
|
||||
#define BUFFER_FLAG_QUEUED (1<<0)
|
||||
uint32_t flags;
|
||||
struct spa_list link;
|
||||
|
@ -716,7 +717,7 @@ static struct buffer *dequeue_buffer(struct impl *this, struct port *port)
|
|||
spa_list_remove(&b->link);
|
||||
SPA_FLAG_UNSET(b->flags, BUFFER_FLAG_QUEUED);
|
||||
spa_log_trace(this->log, NAME " %p: dequeue buffer %d on port %d %u",
|
||||
this, b->buf->id, port->id, b->flags);
|
||||
this, b->id, port->id, b->flags);
|
||||
|
||||
return b;
|
||||
}
|
||||
|
@ -751,6 +752,7 @@ impl_node_port_use_buffers(struct spa_node *node,
|
|||
struct spa_data *d = buffers[i]->datas;
|
||||
|
||||
b = &port->buffers[i];
|
||||
b->id = i;
|
||||
b->buf = buffers[i];
|
||||
b->flags = 0;
|
||||
|
||||
|
@ -923,7 +925,7 @@ static int impl_node_process(struct spa_node *node)
|
|||
dd[j].chunk->size = n_samples * outport->stride;
|
||||
}
|
||||
outio->status = SPA_STATUS_HAVE_BUFFER;
|
||||
outio->buffer_id = dbuf->buf->id;
|
||||
outio->buffer_id = dbuf->id;
|
||||
res |= SPA_STATUS_HAVE_BUFFER;
|
||||
}
|
||||
|
||||
|
|
|
@ -56,6 +56,7 @@ struct props {
|
|||
#define MAX_BUFFERS 32
|
||||
|
||||
struct buffer {
|
||||
uint32_t id;
|
||||
struct spa_buffer *buf;
|
||||
struct spa_meta_header *h;
|
||||
bool outstanding;
|
||||
|
@ -500,8 +501,8 @@ static int flush_data(struct impl *this, uint64_t now_time)
|
|||
if (this->ready_offset >= d[0].chunk->size) {
|
||||
spa_list_remove(&b->link);
|
||||
b->outstanding = true;
|
||||
spa_log_trace(this->log, "a2dp-sink %p: reuse buffer %u", this, b->buf->id);
|
||||
this->callbacks->reuse_buffer(this->callbacks_data, 0, b->buf->id);
|
||||
spa_log_trace(this->log, "a2dp-sink %p: reuse buffer %u", this, b->id);
|
||||
this->callbacks->reuse_buffer(this->callbacks_data, 0, b->id);
|
||||
this->ready_offset = 0;
|
||||
}
|
||||
total_frames += n_frames;
|
||||
|
@ -1171,6 +1172,7 @@ impl_node_port_use_buffers(struct spa_node *node,
|
|||
uint32_t type;
|
||||
|
||||
b->buf = buffers[i];
|
||||
b->id = i;
|
||||
b->outstanding = true;
|
||||
|
||||
b->h = spa_buffer_find_meta_data(buffers[i], SPA_META_Header, sizeof(*b->h));
|
||||
|
|
|
@ -64,10 +64,11 @@ static void reset_props(struct props *props)
|
|||
#define BUFFER_FLAG_MAPPED (1<<2)
|
||||
|
||||
struct buffer {
|
||||
uint32_t id;
|
||||
uint32_t flags;
|
||||
struct spa_list link;
|
||||
struct spa_buffer *outbuf;
|
||||
struct spa_meta_header *h;
|
||||
uint32_t flags;
|
||||
struct v4l2_buffer v4l2_buffer;
|
||||
void *ptr;
|
||||
};
|
||||
|
@ -922,9 +923,9 @@ static int impl_node_process(struct spa_node *node)
|
|||
b = spa_list_first(&port->queue, struct buffer, link);
|
||||
spa_list_remove(&b->link);
|
||||
|
||||
spa_log_trace(this->log, NAME " %p: dequeue buffer %d", node, b->outbuf->id);
|
||||
spa_log_trace(this->log, NAME " %p: dequeue buffer %d", node, b->id);
|
||||
|
||||
io->buffer_id = b->outbuf->id;
|
||||
io->buffer_id = b->id;
|
||||
io->status = SPA_STATUS_HAVE_BUFFER;
|
||||
|
||||
return SPA_STATUS_HAVE_BUFFER;
|
||||
|
|
|
@ -1250,6 +1250,7 @@ static int spa_v4l2_use_buffers(struct impl *this, struct spa_buffer **buffers,
|
|||
struct buffer *b;
|
||||
|
||||
b = &port->buffers[i];
|
||||
b->id = i;
|
||||
b->outbuf = buffers[i];
|
||||
b->flags = BUFFER_FLAG_OUTSTANDING;
|
||||
b->h = spa_buffer_find_meta_data(buffers[i], SPA_META_Header, sizeof(*b->h));
|
||||
|
@ -1294,7 +1295,7 @@ static int spa_v4l2_use_buffers(struct impl *this, struct spa_buffer **buffers,
|
|||
else
|
||||
return -EIO;
|
||||
|
||||
spa_v4l2_buffer_recycle(this, buffers[i]->id);
|
||||
spa_v4l2_buffer_recycle(this, i);
|
||||
}
|
||||
port->n_buffers = reqbuf.count;
|
||||
|
||||
|
|
107
spa/tests/auto/test-buffer.c
Normal file
107
spa/tests/auto/test-buffer.c
Normal file
|
@ -0,0 +1,107 @@
|
|||
/* Simple Plugin API
|
||||
* Copyright © 2018 Collabora Ltd.
|
||||
* @author George Kiagiadakis <george.kiagiadakis@collabora.com>
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a
|
||||
* copy of this software and associated documentation files (the "Software"),
|
||||
* to deal in the Software without restriction, including without limitation
|
||||
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
||||
* and/or sell copies of the Software, and to permit persons to whom the
|
||||
* Software is furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice (including the next
|
||||
* paragraph) shall be included in all copies or substantial portions of the
|
||||
* Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
||||
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
||||
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
||||
* DEALINGS IN THE SOFTWARE.
|
||||
*/
|
||||
|
||||
#include <spa/buffer/alloc.h>
|
||||
#include <spa/buffer/buffer.h>
|
||||
#include <spa/buffer/meta.h>
|
||||
|
||||
static void test_abi(void)
|
||||
{
|
||||
/* buffer */
|
||||
spa_assert(SPA_DATA_Invalid == 0);
|
||||
spa_assert(SPA_DATA_MemPtr == 1);
|
||||
spa_assert(SPA_DATA_MemFd == 2);
|
||||
spa_assert(SPA_DATA_DmaBuf == 3);
|
||||
spa_assert(SPA_DATA_LAST == 4);
|
||||
|
||||
spa_assert(sizeof(struct spa_chunk) == 16);
|
||||
spa_assert(sizeof(struct spa_data) == 40);
|
||||
spa_assert(sizeof(struct spa_buffer) == 24);
|
||||
|
||||
/* meta */
|
||||
spa_assert(SPA_META_Invalid == 0);
|
||||
spa_assert(SPA_META_Header == 1);
|
||||
spa_assert(SPA_META_VideoCrop == 2);
|
||||
spa_assert(SPA_META_VideoDamage == 3);
|
||||
spa_assert(SPA_META_Bitmap == 4);
|
||||
spa_assert(SPA_META_Cursor == 5);
|
||||
spa_assert(SPA_META_LAST == 6);
|
||||
|
||||
spa_assert(sizeof(struct spa_meta) == 16);
|
||||
spa_assert(sizeof(struct spa_meta_header) == 24);
|
||||
spa_assert(sizeof(struct spa_meta_region) == 16);
|
||||
spa_assert(sizeof(struct spa_meta_bitmap) == 20);
|
||||
spa_assert(sizeof(struct spa_meta_cursor) == 28);
|
||||
|
||||
}
|
||||
|
||||
static void test_alloc(void)
|
||||
{
|
||||
struct spa_buffer **buffers;
|
||||
struct spa_meta metas[4];
|
||||
struct spa_data datas[4];
|
||||
uint32_t aligns[4];
|
||||
int i, j;
|
||||
|
||||
metas[0].type = SPA_META_Header;
|
||||
metas[0].size = sizeof(struct spa_meta_header);
|
||||
metas[1].type = SPA_META_VideoDamage;
|
||||
metas[1].size = sizeof(struct spa_meta_region) * 16;
|
||||
#define CURSOR_META_SIZE(w,h,bpp) (sizeof(struct spa_meta_cursor) + \
|
||||
sizeof(struct spa_meta_bitmap) + w * h * bpp)
|
||||
metas[2].type = SPA_META_Cursor;
|
||||
metas[2].size = CURSOR_META_SIZE(64,64,4);
|
||||
|
||||
datas[0].maxsize = 4096;
|
||||
datas[1].maxsize = 2048;
|
||||
|
||||
aligns[0] = 16;
|
||||
aligns[1] = 16;
|
||||
|
||||
buffers = spa_buffer_alloc_array(16, 0, 3, metas, 2, datas, aligns);
|
||||
|
||||
for (i = 0; i < 4; i++) {
|
||||
struct spa_buffer *b = buffers[i];
|
||||
|
||||
spa_assert(b->n_metas == 3);
|
||||
spa_assert(b->n_datas == 2);
|
||||
|
||||
for (j = 0; j < 3; j++) {
|
||||
spa_assert(b->metas[j].type == metas[j].type);
|
||||
spa_assert(b->metas[j].size == metas[j].size);
|
||||
}
|
||||
|
||||
for (j = 0; j < 2; j++) {
|
||||
spa_assert(b->datas[j].maxsize == datas[j].maxsize);
|
||||
}
|
||||
}
|
||||
free(buffers);
|
||||
}
|
||||
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
test_abi();
|
||||
test_alloc();
|
||||
return 0;
|
||||
}
|
|
@ -114,7 +114,6 @@ init_buffer(struct data *data, struct spa_buffer **bufs, struct buffer *ba, int
|
|||
struct buffer *b = &ba[i];
|
||||
bufs[i] = &b->buffer;
|
||||
|
||||
b->buffer.id = i;
|
||||
b->buffer.metas = b->metas;
|
||||
b->buffer.n_metas = 1;
|
||||
b->buffer.datas = b->datas;
|
||||
|
|
|
@ -81,7 +81,6 @@ init_buffer(struct data *data, struct spa_buffer **bufs, struct buffer *ba, int
|
|||
struct buffer *b = &ba[i];
|
||||
bufs[i] = &b->buffer;
|
||||
|
||||
b->buffer.id = i;
|
||||
b->buffer.metas = b->metas;
|
||||
b->buffer.n_metas = 1;
|
||||
b->buffer.datas = b->datas;
|
||||
|
|
|
@ -115,7 +115,6 @@ init_buffer(struct data *data, struct spa_buffer **bufs, struct buffer *ba, int
|
|||
struct buffer *b = &ba[i];
|
||||
bufs[i] = &b->buffer;
|
||||
|
||||
b->buffer.id = i;
|
||||
b->buffer.metas = b->metas;
|
||||
b->buffer.n_metas = 1;
|
||||
b->buffer.datas = b->datas;
|
||||
|
|
|
@ -131,7 +131,6 @@ init_buffer(struct data *data, struct spa_buffer **bufs, struct buffer *ba, int
|
|||
struct buffer *b = &ba[i];
|
||||
bufs[i] = &b->buffer;
|
||||
|
||||
b->buffer.id = i;
|
||||
b->buffer.metas = b->metas;
|
||||
b->buffer.n_metas = 1;
|
||||
b->buffer.datas = b->datas;
|
||||
|
|
|
@ -113,7 +113,6 @@ init_buffer(struct data *data, struct spa_buffer **bufs, struct buffer *ba, int
|
|||
struct buffer *b = &ba[i];
|
||||
bufs[i] = &b->buffer;
|
||||
|
||||
b->buffer.id = i;
|
||||
b->buffer.metas = b->metas;
|
||||
b->buffer.n_metas = 1;
|
||||
b->buffer.datas = b->datas;
|
||||
|
|
|
@ -86,7 +86,6 @@ init_buffer(struct data *data, struct spa_buffer **bufs, struct buffer *ba, int
|
|||
struct buffer *b = &ba[i];
|
||||
bufs[i] = &b->buffer;
|
||||
|
||||
b->buffer.id = i;
|
||||
b->buffer.metas = b->metas;
|
||||
b->buffer.n_metas = 1;
|
||||
b->buffer.datas = b->datas;
|
||||
|
|
|
@ -317,7 +317,6 @@ static int setup_buffers(struct data *data)
|
|||
|
||||
b->texture = NULL;
|
||||
|
||||
b->buffer.id = i;
|
||||
b->buffer.metas = b->metas;
|
||||
b->buffer.n_metas = 1;
|
||||
b->buffer.datas = b->datas;
|
||||
|
|
|
@ -39,6 +39,7 @@
|
|||
#define BUFFER_SAMPLES 128
|
||||
|
||||
struct buffer {
|
||||
uint32_t id;
|
||||
struct spa_buffer *buffer;
|
||||
struct spa_list link;
|
||||
void *ptr;
|
||||
|
@ -359,6 +360,7 @@ static int impl_port_use_buffers(struct spa_node *node, enum spa_direction direc
|
|||
pw_log_error("invalid buffer mem");
|
||||
return -EINVAL;
|
||||
}
|
||||
b->id = i;
|
||||
b->buffer = buffers[i];
|
||||
pw_log_info("got buffer %d size %d", i, datas[0].maxsize);
|
||||
spa_list_append(&d->empty, &b->link);
|
||||
|
@ -464,7 +466,7 @@ static int impl_node_process(struct spa_node *node)
|
|||
od[0].chunk->size = avail;
|
||||
od[0].chunk->stride = 0;
|
||||
|
||||
io->buffer_id = b->buffer->id;
|
||||
io->buffer_id = b->id;
|
||||
io->status = SPA_STATUS_HAVE_BUFFER;
|
||||
|
||||
update_volume(d);
|
||||
|
|
|
@ -98,7 +98,7 @@ on_process(void *_data)
|
|||
|
||||
buf = b->buffer;
|
||||
|
||||
pw_log_trace("new buffer %d", buf->id);
|
||||
pw_log_trace("new buffer %p", buf);
|
||||
|
||||
handle_events(data);
|
||||
|
||||
|
|
|
@ -97,7 +97,6 @@ struct node {
|
|||
static void init_buffer(struct port *port, uint32_t id)
|
||||
{
|
||||
struct buffer *b = &port->buffers[id];
|
||||
b->buf.id = id;
|
||||
b->buf.n_metas = 0;
|
||||
b->buf.metas = NULL;
|
||||
b->buf.n_datas = 1;
|
||||
|
|
|
@ -55,14 +55,13 @@ static void port_props_reset(struct port_props *props)
|
|||
}
|
||||
|
||||
struct buffer {
|
||||
struct spa_list link;
|
||||
uint32_t id;
|
||||
#define BUFFER_FLAG_QUEUED (1 << 0)
|
||||
uint32_t flags;
|
||||
|
||||
struct spa_list link;
|
||||
struct spa_buffer *buffer;
|
||||
struct spa_meta_header *h;
|
||||
|
||||
uint32_t id;
|
||||
struct spa_buffer buf;
|
||||
struct spa_data datas[1];
|
||||
struct spa_chunk chunk[1];
|
||||
|
@ -505,7 +504,7 @@ static int queue_buffer(struct impl *this, struct port *port, struct buffer *b)
|
|||
|
||||
spa_list_append(&port->queue, &b->link);
|
||||
SPA_FLAG_SET(b->flags, BUFFER_FLAG_QUEUED);
|
||||
spa_log_trace(this->log, NAME " %p: queue buffer %d", this, b->buffer->id);
|
||||
spa_log_trace(this->log, NAME " %p: queue buffer %d", this, b->id);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
@ -519,7 +518,7 @@ static struct buffer *dequeue_buffer(struct impl *this, struct port *port)
|
|||
b = spa_list_first(&port->queue, struct buffer, link);
|
||||
spa_list_remove(&b->link);
|
||||
SPA_FLAG_UNSET(b->flags, BUFFER_FLAG_QUEUED);
|
||||
spa_log_trace(this->log, NAME " %p: dequeue buffer %d", this, b->buffer->id);
|
||||
spa_log_trace(this->log, NAME " %p: dequeue buffer %d", this, b->id);
|
||||
return b;
|
||||
}
|
||||
|
||||
|
@ -827,12 +826,10 @@ static int impl_node_process(struct spa_node *node)
|
|||
|
||||
if (n_buffers == 1) {
|
||||
*outb->buffer = *buffers[0]->buffer;
|
||||
outb->buffer->id = outb->id;
|
||||
}
|
||||
else {
|
||||
float *dst;
|
||||
|
||||
outb->buffer->id = outb->id;
|
||||
outb->buffer->n_datas = 1;
|
||||
outb->buffer->datas = outb->datas;
|
||||
outb->datas[0].data = this->empty;
|
||||
|
@ -855,7 +852,7 @@ static int impl_node_process(struct spa_node *node)
|
|||
}
|
||||
}
|
||||
|
||||
outio->buffer_id = outb->buffer->id;
|
||||
outio->buffer_id = outb->id;
|
||||
outio->status = SPA_STATUS_HAVE_BUFFER;
|
||||
|
||||
return SPA_STATUS_HAVE_BUFFER | SPA_STATUS_NEED_BUFFER;
|
||||
|
|
|
@ -346,7 +346,6 @@ static int client_node_demarshal_port_use_buffers(void *object, void *data, size
|
|||
"i", &buffers[i].mem_id,
|
||||
"i", &buffers[i].offset,
|
||||
"i", &buffers[i].size,
|
||||
"i", &buf->id,
|
||||
"i", &buf->n_metas, NULL) < 0)
|
||||
return -EINVAL;
|
||||
|
||||
|
@ -619,7 +618,6 @@ client_node_marshal_port_use_buffers(void *object,
|
|||
"i", buffers[i].mem_id,
|
||||
"i", buffers[i].offset,
|
||||
"i", buffers[i].size,
|
||||
"i", buf->id,
|
||||
"i", buf->n_metas, NULL);
|
||||
|
||||
for (j = 0; j < buf->n_metas; j++) {
|
||||
|
|
|
@ -483,7 +483,6 @@ static int alloc_buffers(struct pw_link *this,
|
|||
|
||||
p = SPA_MEMBER(m->ptr, data_size * i, void);
|
||||
|
||||
b->id = i;
|
||||
b->n_metas = n_metas;
|
||||
b->metas = SPA_MEMBER(b, sizeof(struct spa_buffer), struct spa_meta);
|
||||
for (j = 0; j < n_metas; j++) {
|
||||
|
|
|
@ -1096,8 +1096,6 @@ client_node_port_use_buffers(void *object,
|
|||
struct buffer_mem);
|
||||
bid->n_mem = 0;
|
||||
|
||||
bid->id = b->id;
|
||||
|
||||
bid->mem[bid->n_mem++] = bmem;
|
||||
m->ref++;
|
||||
|
||||
|
|
|
@ -577,7 +577,7 @@ static int impl_port_use_buffers(struct spa_node *node, enum spa_direction direc
|
|||
struct buffer *b = &impl->buffers[i];
|
||||
|
||||
b->flags = 0;
|
||||
b->id = buffers[i]->id;
|
||||
b->id = i;
|
||||
|
||||
if (SPA_FLAG_CHECK(flags, PW_STREAM_FLAG_MAP_BUFFERS)) {
|
||||
for (j = 0; j < buffers[i]->n_datas; j++) {
|
||||
|
@ -1277,14 +1277,9 @@ struct pw_buffer *pw_stream_dequeue_buffer(struct pw_stream *stream)
|
|||
int pw_stream_queue_buffer(struct pw_stream *stream, struct pw_buffer *buffer)
|
||||
{
|
||||
struct stream *impl = SPA_CONTAINER_OF(stream, struct stream, this);
|
||||
struct buffer *b;
|
||||
struct buffer *b = SPA_CONTAINER_OF(buffer, struct buffer, this);
|
||||
int res;
|
||||
|
||||
if ((b = get_buffer(stream, buffer->buffer->id)) == NULL) {
|
||||
pw_log_error("stream %p: invalid buffer %d", stream, buffer->buffer->id);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
pw_log_trace("stream %p: queue buffer %d", stream, b->id);
|
||||
if ((res = push_queue(impl, &impl->queued, b)) < 0)
|
||||
return res;
|
||||
|
|
Loading…
Reference in a new issue