[PATCH v7 16/33] raop: Rework packet's store memory management

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



From: Martin Blanchard <tchaik@xxxxxxx>

This patch switch the packet-buffer to use core memory pool instead of
manually allocating the room required for storing TCP/UDP packets. Packets
are now stored using pa_memchunk instead of internal struct. Quite a few
malloc saved compare to previous design.
---
 src/modules/raop/raop-client.c        | 261 ++++++++++++++++++----------------
 src/modules/raop/raop-packet-buffer.c | 187 +++++++++---------------
 src/modules/raop/raop-packet-buffer.h |  17 +--
 src/modules/raop/raop-sink.c          |   4 +-
 4 files changed, 216 insertions(+), 253 deletions(-)

diff --git a/src/modules/raop/raop-client.c b/src/modules/raop/raop-client.c
index f1e5970..195b00c 100644
--- a/src/modules/raop/raop-client.c
+++ b/src/modules/raop/raop-client.c
@@ -65,6 +65,8 @@
 #define FRAMES_PER_TCP_PACKET 4096
 #define FRAMES_PER_UDP_PACKET 352
 
+#define RTX_BUFFERING_SECONDS 4
+
 #define DEFAULT_TCP_AUDIO_PORT   6000
 #define DEFAULT_UDP_AUDIO_PORT   6000
 #define DEFAULT_UDP_CONTROL_PORT 6001
@@ -323,92 +325,102 @@ static size_t write_AAC_data(uint8_t *packet, const size_t max, uint8_t *raw, si
     return size;
 }
 
-static size_t build_tcp_audio_packet(pa_raop_client *c, uint8_t *raw, size_t *index, size_t *length, uint32_t **packet) {
-    const size_t max = sizeof(tcp_audio_header) + 8 + 16384;
+static size_t build_tcp_audio_packet(pa_raop_client *c, pa_memchunk *block, pa_memchunk *packet) {
+    const size_t head = sizeof(tcp_audio_header);
     uint32_t *buffer = NULL;
-    size_t size, head;
+    uint8_t *raw = NULL;
+    size_t length, size;
 
-    *packet = NULL;
-    if (!(buffer = pa_xmalloc0(max)))
-        return 0;
+    raw = pa_memblock_acquire(block->memblock);
+    buffer = pa_memblock_acquire(packet->memblock);
+    buffer += packet->index / sizeof(uint32_t);
+    raw += block->index;
 
-    size = head = sizeof(tcp_audio_header);
+    c->seq++;
     memcpy(buffer, tcp_audio_header, sizeof(tcp_audio_header));
     buffer[1] |= htonl((uint32_t) c->seq);
     buffer[2] = htonl(c->rtptime);
     buffer[3] = htonl(c->ssrc);
 
+    length = block->length;
+    size = sizeof(tcp_audio_header);
     if (c->codec == PA_RAOP_CODEC_PCM)
-        size += write_PCM_data(((uint8_t *) buffer + head), max - head, raw, length);
+        size += write_PCM_data(((uint8_t *) buffer + head), packet->length - head, raw, &length);
     else if (c->codec == PA_RAOP_CODEC_ALAC)
-        size += write_ALAC_data(((uint8_t *) buffer + head), max - head, raw, length, false);
+        size += write_ALAC_data(((uint8_t *) buffer + head), packet->length - head, raw, &length, false);
     else
-        size += write_AAC_data(((uint8_t *) buffer + head), max - head, raw, length);
-    c->rtptime += *length / 4;
+        size += write_AAC_data(((uint8_t *) buffer + head), packet->length - head, raw, &length);
+    c->rtptime += length / 4;
+
+    pa_memblock_release(block->memblock);
 
     buffer[0] |= htonl((uint32_t) size - 4);
     if (c->encryption == PA_RAOP_ENCRYPTION_RSA)
         pa_raop_aes_encrypt(c->secret, (uint8_t *) buffer + head, size - head);
 
-    *packet = buffer;
+    pa_memblock_release(packet->memblock);
+    packet->length = size;
+
     return size;
 }
 
 static ssize_t send_tcp_audio_packet(pa_raop_client *c, pa_memchunk *block, size_t offset) {
-    static uint32_t * packet = NULL;
-    static size_t size, sent;
+    static int write_type = 0;
+    const size_t max = sizeof(tcp_audio_header) + 8 + 16384;
+    pa_memchunk *packet = NULL;
+    uint8_t *buffer = NULL;
     double progress = 0.0;
-    size_t index, length;
-    uint8_t *raw = NULL;
-    ssize_t written;
+    ssize_t written = -1;
+    size_t done = 0;
+
+    if (!(packet = pa_raop_packet_buffer_get(c->pbuf, c->seq, max)))
+        return -1;
 
-    if (!packet) {
-        index = block->index;
-        length = block->length;
-        raw = pa_memblock_acquire(block->memblock);
+    if (packet->length <= 0) {
+        pa_assert(block->index == offset);
 
-        pa_assert(raw);
-        pa_assert(index == offset);
-        pa_assert(length > 0);
+        if (!(packet = pa_raop_packet_buffer_get(c->pbuf, c->seq + 1, max)))
+            return -1;
 
-        size = build_tcp_audio_packet(c, raw, &index, &length, &packet);
-        sent = 0;
+        packet->index = 0;
+        packet->length = max;
+        if (!build_tcp_audio_packet(c, block, packet))
+            return -1;
     }
 
-    written = -1;
-    if (packet != NULL && size > 0)
-        written = pa_write(c->tcp_sfd, packet + sent, size - sent, NULL);
-    if (block->index == offset)
-        c->seq++;
-    if (sent == 0)
-        pa_memblock_release(block->memblock);
+    buffer = pa_memblock_acquire(packet->memblock);
+
+    pa_assert(buffer);
+
+    buffer += packet->index;
+    if (buffer && packet->length > 0)
+        written = pa_write(c->tcp_sfd, buffer, packet->length, &write_type);
     if (written > 0) {
-        sent += written;
-        progress = (double) sent / (double) size;
-        index = (block->index + block->length) * progress;
-        length = (block->index + block->length) - index;
-        block->length = length;
-        block->index = index;
-    }
+        progress = (double) written / (double) packet->length;
+        packet->length -= written;
+        packet->index += written;
 
-    if ((size - sent) <= 0) {
-        pa_xfree(packet);
-        packet = NULL;
+        done = block->length * progress;
+        block->length -= done;
+        block->index += done;
     }
 
+    pa_memblock_release(packet->memblock);
+
     return written;
 }
 
-static size_t build_udp_audio_packet(pa_raop_client *c, uint8_t *raw, size_t *index, size_t *length, uint32_t **packet) {
-    const size_t max = sizeof(udp_audio_header) + 8 + 1408;
+static size_t build_udp_audio_packet(pa_raop_client *c, pa_memchunk *block, pa_memchunk *packet) {
+    const size_t head = sizeof(udp_audio_header);
     uint32_t *buffer = NULL;
-    size_t size, head;
+    uint8_t *raw = NULL;
+    size_t length, size;
 
-    *packet = NULL;
-    if (!(buffer = pa_xmalloc0(max)))
-        return 0;
+    raw = pa_memblock_acquire(block->memblock);
+    buffer = pa_memblock_acquire(packet->memblock);
+    buffer += packet->index / sizeof(uint32_t);
+    raw += block->index;
 
-    size = head = sizeof(udp_audio_header);
     memcpy(buffer, udp_audio_header, sizeof(udp_audio_header));
     if (c->is_first_packet)
         buffer[0] |= htonl((uint32_t) 0x80 << 16);
@@ -416,75 +428,79 @@ static size_t build_udp_audio_packet(pa_raop_client *c, uint8_t *raw, size_t *in
     buffer[1] = htonl(c->rtptime);
     buffer[2] = htonl(c->ssrc);
 
+    length = block->length;
+    size = sizeof(udp_audio_header);
     if (c->codec == PA_RAOP_CODEC_PCM)
-        size += write_PCM_data(((uint8_t *) buffer + head), max - head, raw + *index, length);
+        size += write_PCM_data(((uint8_t *) buffer + head), packet->length - head, raw, &length);
     else if (c->codec == PA_RAOP_CODEC_ALAC)
-        size += write_ALAC_data(((uint8_t *) buffer + head), max - head, raw + *index, length, false);
+        size += write_ALAC_data(((uint8_t *) buffer + head), packet->length - head, raw, &length, false);
     else
-        size += write_AAC_data(((uint8_t *) buffer + head), max - head, raw + *index, length);
-    c->rtptime += *length / 4;
+        size += write_AAC_data(((uint8_t *) buffer + head), packet->length - head, raw, &length);
+    c->rtptime += length / 4;
+    c->seq++;
+
+    pa_memblock_release(block->memblock);
 
     if (c->encryption == PA_RAOP_ENCRYPTION_RSA)
         pa_raop_aes_encrypt(c->secret, (uint8_t *) buffer + head, size - head);
 
-    *index += *length;
-    *length = 0;
-    /* It is meaningless to preseve the partial data -> */
-    *packet = buffer;
+    pa_memblock_release(packet->memblock);
+    packet->length = size;
+
     return size;
 }
 
 static ssize_t send_udp_audio_packet(pa_raop_client *c, pa_memchunk *block, size_t offset) {
-    uint32_t *packet = NULL;
-    size_t index, length, size;
-    uint8_t *raw = NULL;
-    ssize_t written;
+    const size_t max = sizeof(udp_audio_retrans_header) + sizeof(udp_audio_header) + 8 + 1408;
+    pa_memchunk *packet = NULL;
+    uint8_t *buffer = NULL;
+    ssize_t written = -1;
 
-    index = block->index;
-    length = block->length;
-    raw = pa_memblock_acquire(block->memblock);
+    /* UDP packet has to be sent at once ! */
+    pa_assert(block->index == offset);
 
-    pa_assert(raw);
-    /* <- UDP packet has to be sent at once ! */
-    pa_assert(index == offset);
-    pa_assert(length > 0);
+    if (!(packet = pa_raop_packet_buffer_get(c->pbuf, c->seq, max)))
+        return -1;
 
-    written = -1;
-    size = build_udp_audio_packet(c, raw, &index, &length, &packet);
-    if (packet != NULL && size > 0)
-        written = pa_write(c->udp_sfd, packet, size, NULL);
-    if (written < 0 && (errno == EAGAIN || errno == EWOULDBLOCK))
-        pa_log_debug("Discarding UDP (audio, seq=%d) packet due to EAGAIN (%s)", c->seq, pa_cstrerror(errno));
-    c->seq++;
+    packet->length = max;
+    packet->index = sizeof(udp_audio_retrans_header);
+    if (!build_udp_audio_packet(c, block, packet))
+        return -1;
 
-    /* Store packet for resending in the packet buffer (UDP). */
-    pa_raop_pb_write_packet(c->pbuf, c->seq, raw + block->index, block->length);
-    pa_xfree(packet);
+    buffer = pa_memblock_acquire(packet->memblock);
 
-    pa_memblock_release(block->memblock);
-    block->length = length;
-    block->index = index;
+    pa_assert(buffer);
+
+    buffer += packet->index;
+    if (buffer && packet->length > 0)
+        written = pa_write(c->udp_sfd, buffer, packet->length, NULL);
+    if (written < 0 && (errno == EAGAIN || errno == EWOULDBLOCK)) {
+        pa_log_debug("Discarding UDP (audio, seq=%d) packet due to EAGAIN (%s)", c->seq, pa_cstrerror(errno));
+        return (ssize_t) packet->length;
+    }
+
+    pa_memblock_release(packet->memblock);
+    /* It is meaningless to preseve the partial data */
+    block->index += block->length;
+    block->length = 0;
 
-    if (written < 0)
-        return (ssize_t) size;
     return written;
 }
 
-static size_t rebuild_udp_audio_packet(pa_raop_client *c, uint16_t seq, uint32_t **packet) {
+static size_t rebuild_udp_audio_packet(pa_raop_client *c, uint16_t seq, pa_memchunk *packet) {
     size_t size = sizeof(udp_audio_retrans_header);
     uint32_t *buffer = NULL;
-    uint8_t *data = NULL;
 
-    size += pa_raop_pb_read_packet(c->pbuf, seq, &data);
-    if (size == sizeof(udp_audio_retrans_header))
-        return 0;
-    if (!(buffer = pa_xmalloc0(size)))
-        return 0;
+    buffer = pa_memblock_acquire(packet->memblock);
 
     memcpy(buffer, udp_audio_retrans_header, sizeof(udp_audio_retrans_header));
     buffer[0] |= htonl((uint32_t) seq);
+    size += packet->length;
+
+    pa_memblock_release(packet->memblock);
+    packet->length += sizeof(udp_audio_retrans_header);
+    packet->index -= sizeof(udp_audio_retrans_header);
 
-    *packet = buffer;
     return size;
 }
 
@@ -493,20 +509,32 @@ static ssize_t resend_udp_audio_packets(pa_raop_client *c, uint16_t seq, uint16_
     int i = 0;
 
     for (i = 0; i < nbp; i++) {
-        uint32_t * packet = NULL;
-        ssize_t written = 0;
-        size_t size = 0;
+        pa_memchunk *packet = NULL;
+        uint8_t *buffer = NULL;
+        ssize_t written = -1;
+
+        if (!(packet = pa_raop_packet_buffer_get(c->pbuf, seq + i, 0)))
+            continue;
+
+        if (packet->index > 0) {
+            if (!rebuild_udp_audio_packet(c, seq + i, packet))
+                continue;
+        }
+
+        pa_assert(packet->index == 0);
+
+        buffer = pa_memblock_acquire(packet->memblock);
 
-        size = rebuild_udp_audio_packet(c, seq, &packet);
-        if (packet != NULL && size > 0)
-            written = pa_write(c->udp_cfd, packet, size, NULL);
+        pa_assert(buffer);
+
+        if (buffer && packet->length > 0)
+            written = pa_write(c->udp_cfd, buffer, packet->length, NULL);
         if (written < 0 && (errno == EAGAIN || errno == EWOULDBLOCK)) {
-            pa_log_debug("Discarding UDP (audio-restransmitted, seq=%d) packet due to EAGAIN", c->seq);
+            pa_log_debug("Discarding UDP (audio-restransmitted, seq=%d) packet due to EAGAIN", seq + i);
             continue;
         }
 
-        if (written > 0)
-            total +=  written;
+        total +=  written;
     }
 
     return total;
@@ -557,17 +585,13 @@ static size_t handle_udp_control_packet(pa_raop_client *c, const uint8_t packet[
     ssize_t written = 0;
 
     /* Control packets are 8 bytes long:  */
-    if (size != 8 || packet[0] != 0x80) {
-        pa_log_debug("Received an invalid control packet...");
+    if (size != 8 || packet[0] != 0x80)
         return 1;
-    }
 
     seq = ntohs((uint16_t) packet[4]);
     nbp = ntohs((uint16_t) packet[6]);
-    if (nbp <= 0) {
-        pa_log_debug("Received an invalid control packet...");
+    if (nbp <= 0)
         return 1;
-    }
 
     /* The market bit is always set (see rfc3550 for packet structure) ! */
     payload = packet[1] ^ 0x80;
@@ -631,10 +655,8 @@ static size_t handle_udp_timing_packet(pa_raop_client *c, const uint8_t packet[]
     uint64_t rci = 0;
 
     /* Timing packets are 32 bytes long: 1 x 8 RTP header (no ssrc) + 3 x 8 NTP timestamps */
-    if (size != 32 || packet[0] != 0x80) {
-        pa_log_debug("Received an invalid UDP timing packet...");
+    if (size != 32 || packet[0] != 0x80)
         return 0;
-    }
 
     rci = timeval_to_ntp(pa_rtclock_get(&tv));
     data = (uint32_t *) (packet + sizeof(udp_timming_header));
@@ -1061,6 +1083,8 @@ static void rtsp_stream_cb(pa_rtsp_client *rtsp, pa_rtsp_state_t state, pa_rtsp_
             if (alt)
                 pa_atoi(alt, &latency);
 
+            pa_raop_packet_buffer_reset(c->pbuf, c->seq);
+
             pa_random(&ssrc, sizeof(ssrc));
             c->is_first_packet = true;
             c->is_recording = true;
@@ -1093,9 +1117,6 @@ static void rtsp_stream_cb(pa_rtsp_client *rtsp, pa_rtsp_state_t state, pa_rtsp_
 
             c->is_recording = false;
 
-            if (c->pbuf)
-                pa_raop_pb_clear(c->pbuf);
-
             if (c->tcp_sfd > 0)
                 pa_close(c->tcp_sfd);
             c->tcp_sfd = -1;
@@ -1124,9 +1145,6 @@ static void rtsp_stream_cb(pa_rtsp_client *rtsp, pa_rtsp_state_t state, pa_rtsp_
 
             c->is_recording = false;
 
-            if (c->pbuf)
-                pa_raop_pb_clear(c->pbuf);
-
             if (c->tcp_sfd > 0)
                 pa_close(c->tcp_sfd);
             c->tcp_sfd = -1;
@@ -1331,6 +1349,7 @@ pa_raop_client* pa_raop_client_new(pa_core *core, const char *host, pa_raop_prot
 
     pa_parsed_address a;
     pa_sample_spec ss;
+    size_t size = 2;
 
     pa_assert(core);
     pa_assert(host);
@@ -1369,6 +1388,8 @@ pa_raop_client* pa_raop_client_new(pa_core *core, const char *host, pa_raop_prot
         c->secret = pa_raop_secret_new();
 
     ss = core->default_sample_spec;
+    if (c->protocol == PA_RAOP_PROTOCOL_UDP)
+        size = RTX_BUFFERING_SECONDS * ss.rate / FRAMES_PER_UDP_PACKET;
 
     c->is_recording = false;
     c->is_first_packet = true;
@@ -1376,7 +1397,7 @@ pa_raop_client* pa_raop_client_new(pa_core *core, const char *host, pa_raop_prot
     c->sync_interval = ss.rate / FRAMES_PER_UDP_PACKET;
     c->sync_count = 0;
 
-    c->pbuf = pa_raop_pb_new(UDP_DEFAULT_PKT_BUF_SIZE);
+    c->pbuf = pa_raop_packet_buffer_new(c->core->mempool, size);
 
     return c;
 }
@@ -1384,7 +1405,7 @@ pa_raop_client* pa_raop_client_new(pa_core *core, const char *host, pa_raop_prot
 void pa_raop_client_free(pa_raop_client *c) {
     pa_assert(c);
 
-    pa_raop_pb_delete(c->pbuf);
+    pa_raop_packet_buffer_free(c->pbuf);
 
     pa_xfree(c->sid);
     pa_xfree(c->sci);
@@ -1686,10 +1707,10 @@ void pa_raop_client_handle_oob_packet(pa_raop_client *c, const int fd, const uin
 
     if (c->protocol == PA_RAOP_PROTOCOL_UDP) {
         if (fd == c->udp_cfd) {
-            pa_log_debug("Received UDP control packet");
+            pa_log_debug("Received UDP control packet...");
             handle_udp_control_packet(c, packet, size);
         } else if (fd == c->udp_tfd) {
-            pa_log_debug("Received UDP timing packet");
+            pa_log_debug("Received UDP timing packet...");
             handle_udp_timing_packet(c, packet, size);
         }
     }
diff --git a/src/modules/raop/raop-packet-buffer.c b/src/modules/raop/raop-packet-buffer.c
index d9d8549..06e3125 100644
--- a/src/modules/raop/raop-packet-buffer.c
+++ b/src/modules/raop/raop-packet-buffer.c
@@ -20,152 +20,99 @@
   USA.
 ***/
 
-#include <stdlib.h>
-#include <limits.h>
-
 #ifdef HAVE_CONFIG_H
 #include <config.h>
 #endif
 
+#include <stdlib.h>
+#include <limits.h>
+
+#include <pulse/xmalloc.h>
+
 #include <pulsecore/core-error.h>
-#include "raop-client.h"
+#include <pulsecore/macro.h>
 
 #include "raop-packet-buffer.h"
 
-/* FRAMES_PER_PACKET*2*2 + sizeof(udp_audio_header) + sizeof(ALAC header), unencoded */
-#define PACKET_SIZE_MAX (352*2*2 + 12 + 7) /* FIXME; hardcoded constant ! */
-/* Header room for packet retransmission header */
-#define RETRANS_HEADER_ROOM 4
-
-/* Packet element */
-struct pa_raop_packet_element {
-    uint16_t  seq_num; /* RTP sequence number (in host byte order) */
-    ssize_t   length;  /* Actual packet length */
-    /* Packet data including RTP header */
-    uint8_t   data[PACKET_SIZE_MAX + RETRANS_HEADER_ROOM];
-};
-
-/* Buffer struct */
 struct pa_raop_packet_buffer {
-    size_t   size;          /* max number of packets in buffer */
-    size_t   start;         /* index of oldest packet */
-    size_t   count;         /* number of packets in buffer */
-    uint16_t first_seq_num; /* Sequence number of first packet in buffer */
-    uint16_t latest_seq_num; /* Debug purpose */
-    pa_raop_packet_element *packets; /* Packet element pointer */
+    pa_memchunk *packets;
+    pa_mempool *mempool;
+    size_t size;
+
+    uint16_t seq;
+    size_t pos;
 };
 
-pa_raop_packet_buffer *pa_raop_pb_new(size_t size) {
-    pa_raop_packet_buffer *pb = pa_xmalloc0(sizeof(*pb));
+pa_raop_packet_buffer *pa_raop_packet_buffer_new(pa_mempool *mempool, const size_t size) {
+    pa_raop_packet_buffer *pb = pa_xnew0(pa_raop_packet_buffer, 1);
 
-    pb->size = size;
-    pb->packets = (pa_raop_packet_element *)
-        pa_xmalloc(size * sizeof(pa_raop_packet_element));
+    pa_assert(mempool);
+    pa_assert(size > 0);
 
-    pa_raop_pb_clear(pb);
+    pb->size = size;
+    pb->mempool = mempool;
+    pb->packets = pa_xnew0(pa_memchunk, size);
+    pb->seq = pb->pos = 0;
 
     return pb;
 }
 
-void pa_raop_pb_clear(pa_raop_packet_buffer *pb) {
-    pb->start = 0;
-    pb->count = 0;
-    pb->first_seq_num = 0;
-    pb->latest_seq_num = 0;
-    memset(pb->packets, 0, pb->size * sizeof(pa_raop_packet_element));
-}
-
-void pa_raop_pb_delete(pa_raop_packet_buffer *pb) {
-    pa_xfree(pb->packets);
-    pa_xfree(pb);
-}
-
-static int pb_is_full(pa_raop_packet_buffer *pb) {
-    return pb->count == pb->size;
-}
-
-static int pb_is_empty(pa_raop_packet_buffer *pb) {
-    return pb->count == 0;
-}
-
-static pa_raop_packet_element *pb_prepare_write(pa_raop_packet_buffer *pb, uint16_t seq) {
-    size_t end = (pb->start + pb->count) % pb->size;
-    pa_raop_packet_element *packet;
-
-    /* Set first packet sequence number in buffer if buffer is empty */
-    if (pb_is_empty(pb))
-        pb->first_seq_num = seq;
-    else
-        pa_assert((uint16_t) (pb->latest_seq_num + 1) == seq);
-
-    packet = &pb->packets[end];
-
-    if (pb_is_full(pb)) {
-        pb->start = (pb->start + 1) % pb->size; /* full, overwrite */
+void pa_raop_packet_buffer_free(pa_raop_packet_buffer *pb) {
+    size_t i;
 
-        /* Set first packet sequence number in buffer
-           to new start packet sequence number */
-        pb->first_seq_num = pb->packets[pb->start].seq_num;
-    } else
-        ++ pb->count;
+    pa_assert(pb);
 
-    pb->latest_seq_num = seq;
+    for (i = 0; pb->packets && i < pb->size; i++) {
+        if (pb->packets[i].memblock)
+            pa_memblock_unref(pb->packets[i].memblock);
+        pa_memchunk_reset(&pb->packets[i]);
+    }
 
-    return packet;
+    pa_xfree(pb->packets);
+    pb->packets = NULL;
+    pa_xfree(pb);
 }
 
-/* Write packet data to packet buffer */
-void pa_raop_pb_write_packet(pa_raop_packet_buffer *pb, uint16_t seq_num, const uint8_t *packet_data, ssize_t packet_length) {
-    pa_raop_packet_element *packet;
+void pa_raop_packet_buffer_reset(pa_raop_packet_buffer *pb, uint16_t seq) {
+    size_t i;
 
     pa_assert(pb);
-    pa_assert(packet_data);
-    pa_assert(packet_length <= PACKET_SIZE_MAX);
-
-    packet = pb_prepare_write(pb, seq_num);
-    packet->seq_num = seq_num;
-    packet->length = packet_length + RETRANS_HEADER_ROOM;
-
-    /* Insert RETRANS_HEADER_ROOM bytes in front of packet data,
-       for retransmission header */
-    memset(packet->data, 0, RETRANS_HEADER_ROOM);
-    memcpy(packet->data + RETRANS_HEADER_ROOM, packet_data, packet_length);
-}
-
-/* l < r?, considers wrapping */
-static bool seq_lt(uint16_t l, uint16_t r) {
-    return l - r > USHRT_MAX/2;
+    pa_assert(pb->packets);
+
+    pb->pos = 0;
+    pb->seq = seq - 1;
+    for (i = 0; i < pb->size; i++) {
+        if (pb->packets[i].memblock)
+            pa_memblock_unref(pb->packets[i].memblock);
+        pa_memchunk_reset(&pb->packets[i]);
+    }
 }
 
-/* Random access to packet from buffer by sequence number for (re-)sending. */
-ssize_t pa_raop_pb_read_packet(pa_raop_packet_buffer *pb, uint16_t seq_num, uint8_t **packet_data) {
-    uint16_t index = 0; /* Index of requested packet */
-    pa_raop_packet_element *packet;
-
-    /* If the buffer is empty, there is no use in calculating indices */
-    if (pb_is_empty(pb))
-        return -1;
-
-    /* If the requested packet is too old (seq_num below first seq number
-       in buffer) or too young (seq_num greater than current seq number),
-       do nothing and return */
-    if (seq_lt(seq_num, pb->first_seq_num))
-        return -1;
+pa_memchunk *pa_raop_packet_buffer_get(pa_raop_packet_buffer *pb, uint16_t seq, const size_t size) {
+    pa_memchunk *packet = NULL;
+    size_t delta, i;
 
-    index = (uint16_t) (seq_num - pb->first_seq_num);
-    if (index >= pb->count)
-        return -1;
-
-    /*  Index of the requested packet in the buffer is calculated
-        using the first sequence number stored in the buffer.
-        The offset (seq_num - first_seq_num) is used to access the array. */
-    packet = &pb->packets[(pb->start + index) % pb->size];
-
-    pa_assert(packet->data[RETRANS_HEADER_ROOM + 2] == (seq_num >> 8));
-    pa_assert(packet->data[RETRANS_HEADER_ROOM + 3] == (seq_num & 0xff));
-    pa_assert(packet_data);
-
-    *packet_data = packet->data;
+    pa_assert(pb);
+    pa_assert(pb->packets);
+    pa_assert(seq > 0);
+
+    if (seq == pb->seq)
+        packet = &pb->packets[pb->pos];
+    else if (seq < pb->seq) {
+        delta = pb->seq - seq;
+        i = (pb->size + pb->pos - delta) % pb->size;
+        if (delta < pb->size)
+            packet = &pb->packets[i];
+    } else {
+        i = (pb->pos + (seq - pb->seq)) % pb->size;
+        if (pb->packets[i].memblock)
+            pa_memblock_unref(pb->packets[i].memblock);
+        pa_memchunk_reset(&pb->packets[i]);
+        pb->packets[i].memblock = pa_memblock_new(pb->mempool, size);
+        packet = &pb->packets[i];
+        pb->seq = seq;
+        pb->pos = i;
+    }
 
-    return packet->length;
+    return packet;
 }
diff --git a/src/modules/raop/raop-packet-buffer.h b/src/modules/raop/raop-packet-buffer.h
index 69a0ce1..b8c7617 100644
--- a/src/modules/raop/raop-packet-buffer.h
+++ b/src/modules/raop/raop-packet-buffer.h
@@ -23,19 +23,16 @@
   USA.
 ***/
 
-struct pa_raop_packet_element;
-typedef struct pa_raop_packet_element pa_raop_packet_element;
+#include <pulsecore/memblock.h>
+#include <pulsecore/memchunk.h>
 
-struct pa_raop_packet_buffer;
 typedef struct pa_raop_packet_buffer pa_raop_packet_buffer;
 
-/* Allocates a new circular packet buffer
-   size: Maximum number of packets to store */
-pa_raop_packet_buffer *pa_raop_pb_new(size_t size);
-void pa_raop_pb_clear(pa_raop_packet_buffer *pb);
-void pa_raop_pb_delete(pa_raop_packet_buffer *pb);
+/* Allocates a new circular packet buffer, size: Maximum number of packets to store */
+pa_raop_packet_buffer *pa_raop_packet_buffer_new(pa_mempool *mempool, const size_t size);
+void pa_raop_packet_buffer_free(pa_raop_packet_buffer *pb);
 
-void pa_raop_pb_write_packet(pa_raop_packet_buffer *pb, uint16_t seq_num, const uint8_t *packet_data, ssize_t packet_length);
-ssize_t pa_raop_pb_read_packet(pa_raop_packet_buffer *pb, uint16_t seq_num, uint8_t **packet_data);
+void pa_raop_packet_buffer_reset(pa_raop_packet_buffer *pb, uint16_t seq);
+pa_memchunk *pa_raop_packet_buffer_get(pa_raop_packet_buffer *pb, uint16_t seq, const size_t size);
 
 #endif
diff --git a/src/modules/raop/raop-sink.c b/src/modules/raop/raop-sink.c
index 22b1ccc..23989d1 100644
--- a/src/modules/raop/raop-sink.c
+++ b/src/modules/raop/raop-sink.c
@@ -333,7 +333,6 @@ static void thread_func(void *userdata) {
         unsigned int i, nbfds = 0;
         pa_usec_t now, estimated, intvl;
         uint64_t position;
-        ssize_t written;
         size_t index;
         int ret;
 
@@ -399,8 +398,7 @@ static void thread_func(void *userdata) {
         pa_assert(u->memchunk.length > 0);
 
         index = u->memchunk.index;
-        written = pa_raop_client_send_audio_packet(u->raop, &u->memchunk, offset);
-        if (written < 0) {
+        if (pa_raop_client_send_audio_packet(u->raop, &u->memchunk, offset) < 0) {
             if (errno == EINTR) {
                 /* Just try again. */
                 pa_log_debug("Failed to write data to FIFO (EINTR), retrying");
-- 
2.9.3



[Index of Archives]     [Linux Audio Users]     [AMD Graphics]     [Linux USB Devel]     [Linux Audio Users]     [Yosemite News]     [Linux Kernel]     [Linux SCSI]

  Powered by Linux