vss: unify calls to the FEC layer

This reorganizes the internal vss data structures a bit to unify calls to the
FEC layer across different senders:
 * each sender supplies its sender_client data via the 'sc' pointer;
 * the init_fec()/send_fec() function pointers are now parameters
   (so that a global variable is not needed);
 * both these functions then operate on the supplied sender_client data;
 * the transport layer can then interpret the sender_client data in
   specific ways, e.g. by accessing sc->private_data;
 * a new 'ready' flag has been added to track transport-layer state;
 * max_slice_size as paramter has been restored (for overriding MPS value).

Note: this is one patch out of several. It comments out now-incompatible
      changes in the API for the sake of being able to compile. However,
      the new global API requires the whole set of patches to be applied.

diff --git a/dccp_send.c b/dccp_send.c
index 0e69a969055f1a8466eae06770f91d7ddcfef6db..b13f719ecf6e4ce0c9e245ce4fd49e74c6fe95d1 100644 (file)
--- a/dccp_send.c
+++ b/dccp_send.c
@@ -141,7 +141,7 @@ static void dccp_post_select(fd_set *rfds, __a_unused fd_set *wfds)
        dfc = para_calloc(sizeof(*dfc));
        sc->private_data = dfc;
        dfc->sc = sc;
-       vss_add_fec_client(self, dfc, &dfc->fc);
+       /* XXX RESOLVED LATER vss_add_fec_client(self, dfc, &dfc->fc); */
 }
 
 static int dccp_com_on(__a_unused struct sender_command_data *scd)

diff --git a/send.h b/send.h
index 72c7a6c6c6313e15d8cd64ceb0997624ef0be52e..f831cbc4839b1eb304a8869e234923f375716e88 100644 (file)
--- a/send.h
+++ b/send.h
@@ -20,6 +20,7 @@ enum {SENDER_ADD, SENDER_DELETE, SENDER_ALLOW, SENDER_DENY, SENDER_ON, SENDER_OF
  * vss_del_fec_client().
  */
 struct fec_client;
+struct sender_client;
 
 /** FEC parameters requested by FEC clients. */
 struct fec_client_parms {
@@ -29,6 +30,20 @@ struct fec_client_parms {
        uint8_t data_slices_per_group;
        /** Maximal number of bytes per slice, initially zero. */
        uint16_t max_slice_bytes;
+       /**
+        * Transport-layer initialisation for FEC support.
+        *
+        * This optional function serves (a) to make the transport layer
+        * ready to send FEC slices and (b) to determine the Maximum
+        * Packet Size (MPS) supported by the connection. The MPS value
+        * determines the largest payload size. This value is used to
+        * send FEC slices that are not larger than the path MTU, to avoid
+        * fragmentation and to maximize packet utilization. The user can
+        * alternatively specify a slice size of up to this value.
+        */
+       int (*init_fec)(struct sender_client *sc);
+       /** Push out FEC-encoded packets */
+       int (*send_fec)(struct sender_client *sc, char *buf, size_t len);
 };
 
 /**

diff --git a/send_common.c b/send_common.c
index ed140c8487ee7fb806d247f7d874855e804efcff..3b238014b526d311e4cb6871ea2aecf5cabe8e5b 100644 (file)
--- a/send_common.c
+++ b/send_common.c
@@ -417,6 +417,7 @@ static int parse_fec_parms(const char *arg, struct sender_command_data *scd)
        ret = -ERRNO_TO_PARA_ERROR(EINVAL);
        if (val < 0 || val > 65535)
                goto out;
+       scd->max_slice_bytes = val;
        /* parse data_slices_per_group */
        b = e + 1;
        e = strchr(b, ':');
@@ -479,6 +480,7 @@ int parse_fec_url(const char *arg, struct sender_command_data *scd)
                goto out;
        }
        /* use default fec parameters. */
+       scd->max_slice_bytes = 0;
        scd->slices_per_group = 16;
        scd->data_slices_per_group = 14;
        ret = 0;

diff --git a/server.h b/server.h
index 822e80e161425ff36fa55b46400f5d580a433c64..43ba841d28681fc06b92c06d7ccfce95a3a6423f 100644 (file)
--- a/server.h
+++ b/server.h
@@ -25,6 +25,8 @@ struct sender_command_data{
        int netmask;
        /** The port number for add/remove. */
        int port;
+       /** Maximal slice size. */
+       uint16_t max_slice_bytes;
        /** Number of data slices plus redundant slices. */
        uint8_t slices_per_group;
        /** Number of slices minus number of redundant slices. */

diff --git a/udp_send.c b/udp_send.c
index 29deafb0e85c209fad5954fe14faf4b432d984e9..478c5d9fcfa58c80097cb21f67a7748c964aae12 100644 (file)
--- a/udp_send.c
+++ b/udp_send.c
@@ -279,7 +279,7 @@ static void udp_add_target(struct sender_command_data *scd)
        para_list_add(&ut->node, &targets);
        ut->fcp.slices_per_group = scd->slices_per_group;
        ut->fcp.data_slices_per_group = scd->data_slices_per_group;
-       vss_add_fec_client(self, ut, &ut->fc);
+       /* XXX RESOLVED LATER vss_add_fec_client(self, ut, &ut->fc); */
 }
 
 static int udp_com_add(struct sender_command_data *scd)

diff --git a/vss.c b/vss.c
index afde0dcb829b42422310eaf33361b990bb98c2ac..4be6e18a6833c313b40c0453a10fe021b75b3ee5 100644 (file)
--- a/vss.c
+++ b/vss.c
@@ -137,8 +137,10 @@ struct fec_group {
 struct fec_client {
        /** If negative, this client is temporarily disabled. */
        int error;
-       /** UDP or DCCP. */
-       struct sender *sender;
+       /** Whether the sender client is ready to push out data. */
+       bool ready;
+       /** The connected sender client (transport layer). */
+       struct sender_client *sc;
        /** Parameters requested by the client. */
        struct fec_client_parms *fcp;
        /** Used by the core FEC code. */
@@ -412,21 +414,20 @@ size_t vss_get_fec_eof_packet(const char **buf)
 /**
  * Add one entry to the list of active fec clients.
  *
- * \param fcp Describes the fec parameters to be used for this client.
- * \param result An opaque pointer that must be used by remove the client later.
+ * \param sc  Generic sender_client data of the transport layer.
+ * \param fcp FEC parameters as supplied by the transport layer.
  *
- * \return Standard.
+ * \return Newly allocated fec_client struct.
  */
-int vss_add_fec_client(struct sender *sender, void *private_data,
-               struct fec_client **result)
+struct fec_client *vss_add_fec_client(struct sender_client *sc,
+                                     struct fec_client_parms *fcp)
 {
        struct fec_client *fc = para_calloc(sizeof(*fc));
 
-       fc->private_data = private_data;
-       fc->sender = sender;
+       fc->sc  = sc;
+       fc->fcp = fcp;
        para_list_add(&fc->node, &fec_client_list);
-       *result = fc;
-       return 1;
+       return fc;
 }
 
 /**
@@ -700,7 +701,6 @@ static void vss_pre_select(struct sched *s, struct task *t)
                list_for_each_entry_safe(fc, tmp, &fec_client_list, node) {
                        fc->first_stream_chunk = -1;
                        fc->error = 0;
-                       fc->fcp = NULL;
                }
                mmd->stream_start.tv_sec = 0;
                mmd->stream_start.tv_usec = 0;
@@ -825,17 +825,23 @@ err:
        mmd->new_vss_status_flags = VSS_NEXT;
 }
 
-static int open_fec_client(struct fec_client *fc)
+static int initialize_fec_client(struct fec_client *fc)
 {
        int ret;
-       struct fec_client_parms *fcp;
+       struct fec_client_parms *fcp = fc->fcp;
 
-       ret = fc->sender->open(fc->private_data, &fc->fcp);
-       if (ret < 0) {
-               fc->fcp = NULL;
-               return ret;
+       if (fcp->init_fec) {
+               /*
+                * Set the maximum slice size to the Maximum Packet Size if the
+                * transport protocol allows to determine this value. The user
+                * can specify a slice size up to this value.
+                */
+               ret = fcp->init_fec(fc->sc);
+               if (ret < 0)
+                       return ret;
+               if (!fcp->max_slice_bytes || fcp->max_slice_bytes > ret)
+                       fcp->max_slice_bytes = ret;
        }
-       fcp = fc->fcp;
        if (fcp->max_slice_bytes < FEC_HEADER_SIZE + fcp->data_slices_per_group)
                return -ERRNO_TO_PARA_ERROR(EINVAL);
        ret = fec_new(fcp->data_slices_per_group, fcp->slices_per_group,
@@ -848,6 +854,7 @@ static int open_fec_client(struct fec_client *fc)
        fc->num_extra_slices = 0;
        fc->extra_src_buf = para_calloc(fc->fcp->max_slice_bytes);
        fc->next_header_time.tv_sec = 0;
+       fc->ready = true;
        return 1;
 err:
        fec_free(fc->parms);
@@ -879,8 +886,8 @@ static void vss_send(struct vss_task *vsst)
        list_for_each_entry_safe(fc, tmp_fc, &fec_client_list, node) {
                if (fc->error < 0)
                        continue;
-               if (!fc->fcp) {
-                       ret = open_fec_client(fc);
+               if (!fc->ready) {
+                       ret = initialize_fec_client(fc);
                        if (ret < 0) {
                                PARA_ERROR_LOG("%s\n", para_strerror(-ret));
                                continue;
@@ -894,9 +901,8 @@ static void vss_send(struct vss_task *vsst)
                        continue;
                PARA_DEBUG_LOG("sending %d:%d (%u bytes)\n", fc->group.num,
                        fc->current_slice_num, fc->fcp->max_slice_bytes);
-               fc->sender->send_fec((char *)fc->enc_buf,
-                       fc->fcp->max_slice_bytes,
-                       fc->private_data);
+               fc->fcp->send_fec(fc->sc, (char *)fc->enc_buf,
+                                 fc->fcp->max_slice_bytes);
                fc->current_slice_num++;
                fec_active = 1;
        }

diff --git a/vss.h b/vss.h
index 3d80274b62fea1f68306eb9b585a411dc90fdcea..9412da81a3841425258c07a52e8a1efeca6f5beb 100644 (file)
--- a/vss.h
+++ b/vss.h
@@ -24,7 +24,7 @@ const char *supported_audio_formats(void);
 /** Currently playing. */
 #define VSS_PLAYING 8
 
-int vss_add_fec_client(struct sender *sender, void *private_data,
-               struct fec_client **result);
+struct fec_client *vss_add_fec_client(struct sender_client *sc,
+                                     struct fec_client_parms *fcp);
 void vss_del_fec_client(struct fec_client *fc);
 size_t vss_get_fec_eof_packet(const char **buf);