code.delx.au - pulseaudio/blob - src/modules/rtp/rtp.c

   1 /***
   2   This file is part of PulseAudio.
   3
   4   Copyright 2006 Lennart Poettering
   5
   6   PulseAudio is free software; you can redistribute it and/or modify
   7   it under the terms of the GNU Lesser General Public License as published
   8   by the Free Software Foundation; either version 2 of the License,
   9   or (at your option) any later version.
  10
  11   PulseAudio is distributed in the hope that it will be useful, but
  12   WITHOUT ANY WARRANTY; without even the implied warranty of
  13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  14   General Public License for more details.
  15
  16   You should have received a copy of the GNU Lesser General Public License
  17   along with PulseAudio; if not, write to the Free Software
  18   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  19   USA.
  20 ***/
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include <config.h>
  24 #endif
  25
  26 #include <fcntl.h>
  27 #include <stdlib.h>
  28 #include <string.h>
  29 #include <errno.h>
  30 #include <arpa/inet.h>
  31 #include <unistd.h>
  32 #include <sys/ioctl.h>
  33
  34 #ifdef HAVE_SYS_FILIO_H
  35 #include <sys/filio.h>
  36 #endif
  37
  38 #include <pulsecore/core-error.h>
  39 #include <pulsecore/log.h>
  40 #include <pulsecore/macro.h>
  41 #include <pulsecore/core-util.h>
  42
  43 #include "rtp.h"
  44
  45 pa_rtp_context* pa_rtp_context_init_send(pa_rtp_context *c, int fd, uint32_t ssrc, uint8_t payload, size_t frame_size) {
  46     pa_assert(c);
  47     pa_assert(fd >= 0);
  48
  49     c->fd = fd;
  50     c->sequence = (uint16_t) (rand()*rand());
  51     c->timestamp = 0;
  52     c->ssrc = ssrc ? ssrc : (uint32_t) (rand()*rand());
  53     c->payload = (uint8_t) (payload & 127U);
  54     c->frame_size = frame_size;
  55
  56     pa_memchunk_reset(&c->memchunk);
  57
  58     return c;
  59 }
  60
  61 #define MAX_IOVECS 16
  62
  63 int pa_rtp_send(pa_rtp_context *c, size_t size, pa_memblockq *q) {
  64     struct iovec iov[MAX_IOVECS];
  65     pa_memblock* mb[MAX_IOVECS];
  66     int iov_idx = 1;
  67     size_t n = 0;
  68
  69     pa_assert(c);
  70     pa_assert(size > 0);
  71     pa_assert(q);
  72
  73     if (pa_memblockq_get_length(q) < size)
  74         return 0;
  75
  76     for (;;) {
  77         int r;
  78         pa_memchunk chunk;
  79
  80         pa_memchunk_reset(&chunk);
  81
  82         if ((r = pa_memblockq_peek(q, &chunk)) >= 0) {
  83
  84             size_t k = n + chunk.length > size ? size - n : chunk.length;
  85
  86             pa_assert(chunk.memblock);
  87
  88             iov[iov_idx].iov_base = ((uint8_t*) pa_memblock_acquire(chunk.memblock) + chunk.index);
  89             iov[iov_idx].iov_len = k;
  90             mb[iov_idx] = chunk.memblock;
  91             iov_idx ++;
  92
  93             n += k;
  94             pa_memblockq_drop(q, k);
  95         }
  96
  97         pa_assert(n % c->frame_size == 0);
  98
  99         if (r < 0 || n >= size || iov_idx >= MAX_IOVECS) {
 100             uint32_t header[3];
 101             struct msghdr m;
 102             ssize_t k;
 103             int i;
 104
 105             if (n > 0) {
 106                 header[0] = htonl(((uint32_t) 2 << 30) | ((uint32_t) c->payload << 16) | ((uint32_t) c->sequence));
 107                 header[1] = htonl(c->timestamp);
 108                 header[2] = htonl(c->ssrc);
 109
 110                 iov[0].iov_base = (void*)header;
 111                 iov[0].iov_len = sizeof(header);
 112
 113                 m.msg_name = NULL;
 114                 m.msg_namelen = 0;
 115                 m.msg_iov = iov;
 116                 m.msg_iovlen = (size_t) iov_idx;
 117                 m.msg_control = NULL;
 118                 m.msg_controllen = 0;
 119                 m.msg_flags = 0;
 120
 121                 k = sendmsg(c->fd, &m, MSG_DONTWAIT);
 122
 123                 for (i = 1; i < iov_idx; i++) {
 124                     pa_memblock_release(mb[i]);
 125                     pa_memblock_unref(mb[i]);
 126                 }
 127
 128                 c->sequence++;
 129             } else
 130                 k = 0;
 131
 132             c->timestamp += (unsigned) (n/c->frame_size);
 133
 134             if (k < 0) {
 135                 if (errno != EAGAIN && errno != EINTR) /* If the queue is full, just ignore it */
 136                     pa_log("sendmsg() failed: %s", pa_cstrerror(errno));
 137                 return -1;
 138             }
 139
 140             if (r < 0 || pa_memblockq_get_length(q) < size)
 141                 break;
 142
 143             n = 0;
 144             iov_idx = 1;
 145         }
 146     }
 147
 148     return 0;
 149 }
 150
 151 pa_rtp_context* pa_rtp_context_init_recv(pa_rtp_context *c, int fd, size_t frame_size) {
 152     pa_assert(c);
 153
 154     c->fd = fd;
 155     c->frame_size = frame_size;
 156
 157     pa_memchunk_reset(&c->memchunk);
 158     return c;
 159 }
 160
 161 int pa_rtp_recv(pa_rtp_context *c, pa_memchunk *chunk, pa_mempool *pool) {
 162     int size;
 163     struct msghdr m;
 164     struct iovec iov;
 165     uint32_t header;
 166     unsigned cc;
 167     ssize_t r;
 168
 169     pa_assert(c);
 170     pa_assert(chunk);
 171
 172     pa_memchunk_reset(chunk);
 173
 174     if (ioctl(c->fd, FIONREAD, &size) < 0) {
 175         pa_log_warn("FIONREAD failed: %s", pa_cstrerror(errno));
 176         goto fail;
 177     }
 178
 179     if (size <= 0)
 180         return 0;
 181
 182     if (c->memchunk.length < (unsigned) size) {
 183         size_t l;
 184
 185         if (c->memchunk.memblock)
 186             pa_memblock_unref(c->memchunk.memblock);
 187
 188         l = PA_MAX((size_t) size, pa_mempool_block_size_max(pool));
 189
 190         c->memchunk.memblock = pa_memblock_new(pool, l);
 191         c->memchunk.index = 0;
 192         c->memchunk.length = pa_memblock_get_length(c->memchunk.memblock);
 193     }
 194
 195     pa_assert(c->memchunk.length >= (size_t) size);
 196
 197     chunk->memblock = pa_memblock_ref(c->memchunk.memblock);
 198     chunk->index = c->memchunk.index;
 199
 200     iov.iov_base = (uint8_t*) pa_memblock_acquire(chunk->memblock) + chunk->index;
 201     iov.iov_len = (size_t) size;
 202
 203     m.msg_name = NULL;
 204     m.msg_namelen = 0;
 205     m.msg_iov = &iov;
 206     m.msg_iovlen = 1;
 207     m.msg_control = NULL;
 208     m.msg_controllen = 0;
 209     m.msg_flags = 0;
 210
 211     r = recvmsg(c->fd, &m, 0);
 212     pa_memblock_release(chunk->memblock);
 213
 214     if (r != size) {
 215         if (r < 0 && errno != EAGAIN && errno != EINTR)
 216             pa_log_warn("recvmsg() failed: %s", r < 0 ? pa_cstrerror(errno) : "size mismatch");
 217
 218         goto fail;
 219     }
 220
 221     if (size < 12) {
 222         pa_log_warn("RTP packet too short.");
 223         goto fail;
 224     }
 225
 226     memcpy(&header, iov.iov_base, sizeof(uint32_t));
 227     memcpy(&c->timestamp, (uint8_t*) iov.iov_base + 4, sizeof(uint32_t));
 228     memcpy(&c->ssrc, (uint8_t*) iov.iov_base + 8, sizeof(uint32_t));
 229
 230     header = ntohl(header);
 231     c->timestamp = ntohl(c->timestamp);
 232     c->ssrc = ntohl(c->ssrc);
 233
 234     if ((header >> 30) != 2) {
 235         pa_log_warn("Unsupported RTP version.");
 236         goto fail;
 237     }
 238
 239     if ((header >> 29) & 1) {
 240         pa_log_warn("RTP padding not supported.");
 241         goto fail;
 242     }
 243
 244     if ((header >> 28) & 1) {
 245         pa_log_warn("RTP header extensions not supported.");
 246         goto fail;
 247     }
 248
 249     cc = (header >> 24) & 0xF;
 250     c->payload = (uint8_t) ((header >> 16) & 127U);
 251     c->sequence = (uint16_t) (header & 0xFFFFU);
 252
 253     if (12 + cc*4 > (unsigned) size) {
 254         pa_log_warn("RTP packet too short. (CSRC)");
 255         goto fail;
 256     }
 257
 258     chunk->index += 12 + cc*4;
 259     chunk->length = (size_t) size - 12 + cc*4;
 260
 261     if (chunk->length % c->frame_size != 0) {
 262         pa_log_warn("Bad RTP packet size.");
 263         goto fail;
 264     }
 265
 266     c->memchunk.index = chunk->index + chunk->length;
 267     c->memchunk.length = pa_memblock_get_length(c->memchunk.memblock) - c->memchunk.index;
 268
 269     if (c->memchunk.length <= 0) {
 270         pa_memblock_unref(c->memchunk.memblock);
 271         pa_memchunk_reset(&c->memchunk);
 272     }
 273
 274     return 0;
 275
 276 fail:
 277     if (chunk->memblock)
 278         pa_memblock_unref(chunk->memblock);
 279
 280     return -1;
 281 }
 282
 283 uint8_t pa_rtp_payload_from_sample_spec(const pa_sample_spec *ss) {
 284     pa_assert(ss);
 285
 286     if (ss->format == PA_SAMPLE_ULAW && ss->rate == 8000 && ss->channels == 1)
 287         return 0;
 288     if (ss->format == PA_SAMPLE_ALAW && ss->rate == 8000 && ss->channels == 1)
 289         return 8;
 290     if (ss->format == PA_SAMPLE_S16BE && ss->rate == 44100 && ss->channels == 2)
 291         return 10;
 292     if (ss->format == PA_SAMPLE_S16BE && ss->rate == 44100 && ss->channels == 1)
 293         return 11;
 294
 295     return 127;
 296 }
 297
 298 pa_sample_spec *pa_rtp_sample_spec_from_payload(uint8_t payload, pa_sample_spec *ss) {
 299     pa_assert(ss);
 300
 301     switch (payload) {
 302         case 0:
 303             ss->channels = 1;
 304             ss->format = PA_SAMPLE_ULAW;
 305             ss->rate = 8000;
 306             break;
 307
 308         case 8:
 309             ss->channels = 1;
 310             ss->format = PA_SAMPLE_ALAW;
 311             ss->rate = 8000;
 312             break;
 313
 314         case 10:
 315             ss->channels = 2;
 316             ss->format = PA_SAMPLE_S16BE;
 317             ss->rate = 44100;
 318             break;
 319
 320         case 11:
 321             ss->channels = 1;
 322             ss->format = PA_SAMPLE_S16BE;
 323             ss->rate = 44100;
 324             break;
 325
 326         default:
 327             return NULL;
 328     }
 329
 330     return ss;
 331 }
 332
 333 pa_sample_spec *pa_rtp_sample_spec_fixup(pa_sample_spec * ss) {
 334     pa_assert(ss);
 335
 336     if (!pa_rtp_sample_spec_valid(ss))
 337         ss->format = PA_SAMPLE_S16BE;
 338
 339     pa_assert(pa_rtp_sample_spec_valid(ss));
 340     return ss;
 341 }
 342
 343 int pa_rtp_sample_spec_valid(const pa_sample_spec *ss) {
 344     pa_assert(ss);
 345
 346     if (!pa_sample_spec_valid(ss))
 347         return 0;
 348
 349     return
 350         ss->format == PA_SAMPLE_U8 ||
 351         ss->format == PA_SAMPLE_ALAW ||
 352         ss->format == PA_SAMPLE_ULAW ||
 353         ss->format == PA_SAMPLE_S16BE;
 354 }
 355
 356 void pa_rtp_context_destroy(pa_rtp_context *c) {
 357     pa_assert(c);
 358
 359     pa_assert_se(pa_close(c->fd) == 0);
 360
 361     if (c->memchunk.memblock)
 362         pa_memblock_unref(c->memchunk.memblock);
 363 }
 364
 365 const char* pa_rtp_format_to_string(pa_sample_format_t f) {
 366     switch (f) {
 367         case PA_SAMPLE_S16BE:
 368             return "L16";
 369         case PA_SAMPLE_U8:
 370             return "L8";
 371         case PA_SAMPLE_ALAW:
 372             return "PCMA";
 373         case PA_SAMPLE_ULAW:
 374             return "PCMU";
 375         default:
 376             return NULL;
 377     }
 378 }
 379
 380 pa_sample_format_t pa_rtp_string_to_format(const char *s) {
 381     pa_assert(s);
 382
 383     if (!(strcmp(s, "L16")))
 384         return PA_SAMPLE_S16BE;
 385     else if (!strcmp(s, "L8"))
 386         return PA_SAMPLE_U8;
 387     else if (!strcmp(s, "PCMA"))
 388         return PA_SAMPLE_ALAW;
 389     else if (!strcmp(s, "PCMU"))
 390         return PA_SAMPLE_ULAW;
 391     else
 392         return PA_SAMPLE_INVALID;
 393 }