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.1 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 <unistd.h>
  31 #include <sys/ioctl.h>
  32
  33 #ifdef HAVE_SYS_FILIO_H
  34 #include <sys/filio.h>
  35 #endif
  36
  37 #ifdef HAVE_SYS_UIO_H
  38 #include <sys/uio.h>
  39 #endif
  40
  41 #include <pulsecore/core-error.h>
  42 #include <pulsecore/log.h>
  43 #include <pulsecore/macro.h>
  44 #include <pulsecore/core-util.h>
  45 #include <pulsecore/arpa-inet.h>
  46
  47 #include "rtp.h"
  48
  49 pa_rtp_context* pa_rtp_context_init_send(pa_rtp_context *c, int fd, uint32_t ssrc, uint8_t payload, size_t frame_size) {
  50     pa_assert(c);
  51     pa_assert(fd >= 0);
  52
  53     c->fd = fd;
  54     c->sequence = (uint16_t) (rand()*rand());
  55     c->timestamp = 0;
  56     c->ssrc = ssrc ? ssrc : (uint32_t) (rand()*rand());
  57     c->payload = (uint8_t) (payload & 127U);
  58     c->frame_size = frame_size;
  59
  60     pa_memchunk_reset(&c->memchunk);
  61
  62     return c;
  63 }
  64
  65 #define MAX_IOVECS 16
  66
  67 int pa_rtp_send(pa_rtp_context *c, size_t size, pa_memblockq *q) {
  68     struct iovec iov[MAX_IOVECS];
  69     pa_memblock* mb[MAX_IOVECS];
  70     int iov_idx = 1;
  71     size_t n = 0;
  72
  73     pa_assert(c);
  74     pa_assert(size > 0);
  75     pa_assert(q);
  76
  77     if (pa_memblockq_get_length(q) < size)
  78         return 0;
  79
  80     for (;;) {
  81         int r;
  82         pa_memchunk chunk;
  83
  84         pa_memchunk_reset(&chunk);
  85
  86         if ((r = pa_memblockq_peek(q, &chunk)) >= 0) {
  87
  88             size_t k = n + chunk.length > size ? size - n : chunk.length;
  89
  90             pa_assert(chunk.memblock);
  91
  92             iov[iov_idx].iov_base = ((uint8_t*) pa_memblock_acquire(chunk.memblock) + chunk.index);
  93             iov[iov_idx].iov_len = k;
  94             mb[iov_idx] = chunk.memblock;
  95             iov_idx ++;
  96
  97             n += k;
  98             pa_memblockq_drop(q, k);
  99         }
 100
 101         pa_assert(n % c->frame_size == 0);
 102
 103         if (r < 0 || n >= size || iov_idx >= MAX_IOVECS) {
 104             uint32_t header[3];
 105             struct msghdr m;
 106             ssize_t k;
 107             int i;
 108
 109             if (n > 0) {
 110                 header[0] = htonl(((uint32_t) 2 << 30) | ((uint32_t) c->payload << 16) | ((uint32_t) c->sequence));
 111                 header[1] = htonl(c->timestamp);
 112                 header[2] = htonl(c->ssrc);
 113
 114                 iov[0].iov_base = (void*)header;
 115                 iov[0].iov_len = sizeof(header);
 116
 117                 m.msg_name = NULL;
 118                 m.msg_namelen = 0;
 119                 m.msg_iov = iov;
 120                 m.msg_iovlen = (size_t) iov_idx;
 121                 m.msg_control = NULL;
 122                 m.msg_controllen = 0;
 123                 m.msg_flags = 0;
 124
 125                 k = sendmsg(c->fd, &m, MSG_DONTWAIT);
 126
 127                 for (i = 1; i < iov_idx; i++) {
 128                     pa_memblock_release(mb[i]);
 129                     pa_memblock_unref(mb[i]);
 130                 }
 131
 132                 c->sequence++;
 133             } else
 134                 k = 0;
 135
 136             c->timestamp += (unsigned) (n/c->frame_size);
 137
 138             if (k < 0) {
 139                 if (errno != EAGAIN && errno != EINTR) /* If the queue is full, just ignore it */
 140                     pa_log("sendmsg() failed: %s", pa_cstrerror(errno));
 141                 return -1;
 142             }
 143
 144             if (r < 0 || pa_memblockq_get_length(q) < size)
 145                 break;
 146
 147             n = 0;
 148             iov_idx = 1;
 149         }
 150     }
 151
 152     return 0;
 153 }
 154
 155 pa_rtp_context* pa_rtp_context_init_recv(pa_rtp_context *c, int fd, size_t frame_size) {
 156     pa_assert(c);
 157
 158     c->fd = fd;
 159     c->frame_size = frame_size;
 160
 161     pa_memchunk_reset(&c->memchunk);
 162     return c;
 163 }
 164
 165 int pa_rtp_recv(pa_rtp_context *c, pa_memchunk *chunk, pa_mempool *pool, struct timeval *tstamp) {
 166     int size;
 167     struct msghdr m;
 168     struct cmsghdr *cm;
 169     struct iovec iov;
 170     uint32_t header;
 171     unsigned cc;
 172     ssize_t r;
 173     uint8_t aux[1024];
 174     pa_bool_t found_tstamp = FALSE;
 175
 176     pa_assert(c);
 177     pa_assert(chunk);
 178
 179     pa_memchunk_reset(chunk);
 180
 181     if (ioctl(c->fd, FIONREAD, &size) < 0) {
 182         pa_log_warn("FIONREAD failed: %s", pa_cstrerror(errno));
 183         goto fail;
 184     }
 185
 186     if (size <= 0)
 187         return 0;
 188
 189     if (c->memchunk.length < (unsigned) size) {
 190         size_t l;
 191
 192         if (c->memchunk.memblock)
 193             pa_memblock_unref(c->memchunk.memblock);
 194
 195         l = PA_MAX((size_t) size, pa_mempool_block_size_max(pool));
 196
 197         c->memchunk.memblock = pa_memblock_new(pool, l);
 198         c->memchunk.index = 0;
 199         c->memchunk.length = pa_memblock_get_length(c->memchunk.memblock);
 200     }
 201
 202     pa_assert(c->memchunk.length >= (size_t) size);
 203
 204     chunk->memblock = pa_memblock_ref(c->memchunk.memblock);
 205     chunk->index = c->memchunk.index;
 206
 207     iov.iov_base = (uint8_t*) pa_memblock_acquire(chunk->memblock) + chunk->index;
 208     iov.iov_len = (size_t) size;
 209
 210     m.msg_name = NULL;
 211     m.msg_namelen = 0;
 212     m.msg_iov = &iov;
 213     m.msg_iovlen = 1;
 214     m.msg_control = aux;
 215     m.msg_controllen = sizeof(aux);
 216     m.msg_flags = 0;
 217
 218     r = recvmsg(c->fd, &m, 0);
 219     pa_memblock_release(chunk->memblock);
 220
 221     if (r != size) {
 222         if (r < 0 && errno != EAGAIN && errno != EINTR)
 223             pa_log_warn("recvmsg() failed: %s", r < 0 ? pa_cstrerror(errno) : "size mismatch");
 224
 225         goto fail;
 226     }
 227
 228     if (size < 12) {
 229         pa_log_warn("RTP packet too short.");
 230         goto fail;
 231     }
 232
 233     memcpy(&header, iov.iov_base, sizeof(uint32_t));
 234     memcpy(&c->timestamp, (uint8_t*) iov.iov_base + 4, sizeof(uint32_t));
 235     memcpy(&c->ssrc, (uint8_t*) iov.iov_base + 8, sizeof(uint32_t));
 236
 237     header = ntohl(header);
 238     c->timestamp = ntohl(c->timestamp);
 239     c->ssrc = ntohl(c->ssrc);
 240
 241     if ((header >> 30) != 2) {
 242         pa_log_warn("Unsupported RTP version.");
 243         goto fail;
 244     }
 245
 246     if ((header >> 29) & 1) {
 247         pa_log_warn("RTP padding not supported.");
 248         goto fail;
 249     }
 250
 251     if ((header >> 28) & 1) {
 252         pa_log_warn("RTP header extensions not supported.");
 253         goto fail;
 254     }
 255
 256     cc = (header >> 24) & 0xF;
 257     c->payload = (uint8_t) ((header >> 16) & 127U);
 258     c->sequence = (uint16_t) (header & 0xFFFFU);
 259
 260     if (12 + cc*4 > (unsigned) size) {
 261         pa_log_warn("RTP packet too short. (CSRC)");
 262         goto fail;
 263     }
 264
 265     chunk->index += 12 + cc*4;
 266     chunk->length = (size_t) size - 12 + cc*4;
 267
 268     if (chunk->length % c->frame_size != 0) {
 269         pa_log_warn("Bad RTP packet size.");
 270         goto fail;
 271     }
 272
 273     c->memchunk.index = chunk->index + chunk->length;
 274     c->memchunk.length = pa_memblock_get_length(c->memchunk.memblock) - c->memchunk.index;
 275
 276     if (c->memchunk.length <= 0) {
 277         pa_memblock_unref(c->memchunk.memblock);
 278         pa_memchunk_reset(&c->memchunk);
 279     }
 280
 281     for (cm = CMSG_FIRSTHDR(&m); cm; cm = CMSG_NXTHDR(&m, cm))
 282         if (cm->cmsg_level == SOL_SOCKET && cm->cmsg_type == SO_TIMESTAMP) {
 283             memcpy(tstamp, CMSG_DATA(cm), sizeof(struct timeval));
 284             found_tstamp = TRUE;
 285             break;
 286         }
 287
 288     if (!found_tstamp) {
 289         pa_log_warn("Couldn't find SO_TIMESTAMP data in auxiliary recvmsg() data!");
 290         memset(tstamp, 0, sizeof(tstamp));
 291     }
 292
 293     return 0;
 294
 295 fail:
 296     if (chunk->memblock)
 297         pa_memblock_unref(chunk->memblock);
 298
 299     return -1;
 300 }
 301
 302 uint8_t pa_rtp_payload_from_sample_spec(const pa_sample_spec *ss) {
 303     pa_assert(ss);
 304
 305     if (ss->format == PA_SAMPLE_ULAW && ss->rate == 8000 && ss->channels == 1)
 306         return 0;
 307     if (ss->format == PA_SAMPLE_ALAW && ss->rate == 8000 && ss->channels == 1)
 308         return 8;
 309     if (ss->format == PA_SAMPLE_S16BE && ss->rate == 44100 && ss->channels == 2)
 310         return 10;
 311     if (ss->format == PA_SAMPLE_S16BE && ss->rate == 44100 && ss->channels == 1)
 312         return 11;
 313
 314     return 127;
 315 }
 316
 317 pa_sample_spec *pa_rtp_sample_spec_from_payload(uint8_t payload, pa_sample_spec *ss) {
 318     pa_assert(ss);
 319
 320     switch (payload) {
 321         case 0:
 322             ss->channels = 1;
 323             ss->format = PA_SAMPLE_ULAW;
 324             ss->rate = 8000;
 325             break;
 326
 327         case 8:
 328             ss->channels = 1;
 329             ss->format = PA_SAMPLE_ALAW;
 330             ss->rate = 8000;
 331             break;
 332
 333         case 10:
 334             ss->channels = 2;
 335             ss->format = PA_SAMPLE_S16BE;
 336             ss->rate = 44100;
 337             break;
 338
 339         case 11:
 340             ss->channels = 1;
 341             ss->format = PA_SAMPLE_S16BE;
 342             ss->rate = 44100;
 343             break;
 344
 345         default:
 346             return NULL;
 347     }
 348
 349     return ss;
 350 }
 351
 352 pa_sample_spec *pa_rtp_sample_spec_fixup(pa_sample_spec * ss) {
 353     pa_assert(ss);
 354
 355     if (!pa_rtp_sample_spec_valid(ss))
 356         ss->format = PA_SAMPLE_S16BE;
 357
 358     pa_assert(pa_rtp_sample_spec_valid(ss));
 359     return ss;
 360 }
 361
 362 int pa_rtp_sample_spec_valid(const pa_sample_spec *ss) {
 363     pa_assert(ss);
 364
 365     if (!pa_sample_spec_valid(ss))
 366         return 0;
 367
 368     return
 369         ss->format == PA_SAMPLE_U8 ||
 370         ss->format == PA_SAMPLE_ALAW ||
 371         ss->format == PA_SAMPLE_ULAW ||
 372         ss->format == PA_SAMPLE_S16BE;
 373 }
 374
 375 void pa_rtp_context_destroy(pa_rtp_context *c) {
 376     pa_assert(c);
 377
 378     pa_assert_se(pa_close(c->fd) == 0);
 379
 380     if (c->memchunk.memblock)
 381         pa_memblock_unref(c->memchunk.memblock);
 382 }
 383
 384 const char* pa_rtp_format_to_string(pa_sample_format_t f) {
 385     switch (f) {
 386         case PA_SAMPLE_S16BE:
 387             return "L16";
 388         case PA_SAMPLE_U8:
 389             return "L8";
 390         case PA_SAMPLE_ALAW:
 391             return "PCMA";
 392         case PA_SAMPLE_ULAW:
 393             return "PCMU";
 394         default:
 395             return NULL;
 396     }
 397 }
 398
 399 pa_sample_format_t pa_rtp_string_to_format(const char *s) {
 400     pa_assert(s);
 401
 402     if (!(strcmp(s, "L16")))
 403         return PA_SAMPLE_S16BE;
 404     else if (!strcmp(s, "L8"))
 405         return PA_SAMPLE_U8;
 406     else if (!strcmp(s, "PCMA"))
 407         return PA_SAMPLE_ALAW;
 408     else if (!strcmp(s, "PCMU"))
 409         return PA_SAMPLE_ULAW;
 410     else
 411         return PA_SAMPLE_INVALID;
 412 }