opusrtp: Fix error if pcap is unavailable
[opus-tools.git] / src / opusrtp.c
1 /* Copyright 2012 Mozilla Foundation
2    Copyright 2012 Xiph.Org Foundation
3    Copyright 2012 Gregory Maxwell
4
5    Redistribution and use in source and binary forms, with or without
6    modification, are permitted provided that the following conditions
7    are met:
8
9    - Redistributions of source code must retain the above copyright
10    notice, this list of conditions and the following disclaimer.
11
12    - Redistributions in binary form must reproduce the above copyright
13    notice, this list of conditions and the following disclaimer in the
14    documentation and/or other materials provided with the distribution.
15
16    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
17    ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
18    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
19    A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR
20    CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
21    EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
22    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
23    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
24    LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
25    NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
26    SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27  */
28
29 /* dump opus rtp packets into an ogg file
30  *
31  * compile with: cc -g -Wall -o opusrtc opusrtp.c -lpcap -logg
32  *
33  */
34
35 #ifdef HAVE_CONFIG_H
36 # include "config.h"
37 #endif
38
39 #include <stdio.h>
40 #include <stdlib.h>
41 #include <string.h>
42 #include <time.h>
43 #include <unistd.h>
44 #include <getopt.h>
45
46 #ifndef _WIN32
47 # include <sys/types.h>
48 # include <sys/socket.h>
49 # include <netinet/in.h>
50 # include <arpa/inet.h>
51 # include <errno.h>
52
53 # if defined HAVE_MACH_ABSOLUTE_TIME
54 #  include <mach/mach_time.h>
55 # elif !(defined HAVE_CLOCK_GETTIME && defined CLOCK_REALTIME && \
56          defined HAVE_NANOSLEEP)
57 #  include <sys/time.h>
58 # endif
59 #endif
60
61 #ifdef HAVE_PCAP
62 # include <pcap.h>
63 #endif
64 #include <opus.h>
65 #include <ogg/ogg.h>
66
67 #define SNIFF_DEVICE "lo0"
68 #define DYNAMIC_PAYLOAD_TYPE_MIN 96
69
70 /* state struct for passing around our handles */
71 typedef struct {
72   ogg_stream_state *stream;
73   FILE *out;
74   int seq;
75   ogg_int64_t granulepos;
76   int linktype;
77   int payload_type;
78 } state;
79
80 /* helper, write a little-endian 32 bit int to memory */
81 void le32(unsigned char *p, int v)
82 {
83   p[0] = v & 0xff;
84   p[1] = (v >> 8) & 0xff;
85   p[2] = (v >> 16) & 0xff;
86   p[3] = (v >> 24) & 0xff;
87 }
88
89 /* helper, write a little-endian 16 bit int to memory */
90 void le16(unsigned char *p, int v)
91 {
92   p[0] = v & 0xff;
93   p[1] = (v >> 8) & 0xff;
94 }
95
96 /* helper, write a big-endian 32 bit int to memory */
97 void be32(unsigned char *p, int v)
98 {
99   p[0] = (v >> 24) & 0xff;
100   p[1] = (v >> 16) & 0xff;
101   p[2] = (v >> 8) & 0xff;
102   p[3] = v & 0xff;
103 }
104
105 /* helper, write a big-endian 16 bit int to memory */
106 void be16(unsigned char *p, int v)
107 {
108   p[0] = (v >> 8) & 0xff;
109   p[1] = v & 0xff;
110 }
111
112 /* manufacture a generic OpusHead packet */
113 ogg_packet *op_opushead(int samplerate, int channels)
114 {
115   int size = 19;
116   unsigned char *data = malloc(size);
117   ogg_packet *op = malloc(sizeof(*op));
118
119   if (!data) {
120     fprintf(stderr, "Couldn't allocate data buffer.\n");
121     free(op);
122     return NULL;
123   }
124   if (!op) {
125     fprintf(stderr, "Couldn't allocate Ogg packet.\n");
126     free(data);
127     return NULL;
128   }
129
130   memcpy(data, "OpusHead", 8);  /* identifier */
131   data[8] = 1;                  /* version */
132   data[9] = channels;           /* channels */
133   le16(data+10, 0);             /* pre-skip */
134   le32(data + 12, samplerate);  /* original sample rate */
135   le16(data + 16, 0);           /* gain */
136   data[18] = 0;                 /* channel mapping family */
137
138   op->packet = data;
139   op->bytes = size;
140   op->b_o_s = 1;
141   op->e_o_s = 0;
142   op->granulepos = 0;
143   op->packetno = 0;
144
145   return op;
146 }
147
148
149 /* manufacture a generic OpusTags packet */
150 ogg_packet *op_opustags(void)
151 {
152   char *identifier = "OpusTags";
153   char *vendor = "opus rtp packet dump";
154   int size = strlen(identifier) + 4 + strlen(vendor) + 4;
155   unsigned char *data = malloc(size);
156   ogg_packet *op = malloc(sizeof(*op));
157
158   if (!data) {
159     fprintf(stderr, "Couldn't allocate data buffer.\n");
160     free(op);
161     return NULL;
162   }
163   if (!op) {
164     fprintf(stderr, "Couldn't allocate Ogg packet.\n");
165     free(data);
166     return NULL;
167   }
168
169   memcpy(data, identifier, 8);
170   le32(data + 8, strlen(vendor));
171   memcpy(data + 12, vendor, strlen(vendor));
172   le32(data + 12 + strlen(vendor), 0);
173
174   op->packet = data;
175   op->bytes = size;
176   op->b_o_s = 0;
177   op->e_o_s = 0;
178   op->granulepos = 0;
179   op->packetno = 1;
180
181   return op;
182 }
183
184 ogg_packet *op_from_pkt(const unsigned char *pkt, int len)
185 {
186   ogg_packet *op = malloc(sizeof(*op));
187   if (!op) {
188     fprintf(stderr, "Couldn't allocate Ogg packet.\n");
189     return NULL;
190   }
191
192   op->packet = (unsigned char *)pkt;
193   op->bytes = len;
194   op->b_o_s = 0;
195   op->e_o_s = 0;
196
197   return op;
198 }
199
200 /* free a packet and its contents */
201 void op_free(ogg_packet *op)
202 {
203   if (op) {
204     if (op->packet) {
205       free(op->packet);
206     }
207     free(op);
208   }
209 }
210
211 /* check if an ogg page begins an opus stream */
212 int is_opus(ogg_page *og)
213 {
214   ogg_stream_state os;
215   ogg_packet op;
216
217   ogg_stream_init(&os, ogg_page_serialno(og));
218   ogg_stream_pagein(&os, og);
219   if (ogg_stream_packetout(&os, &op) == 1) {
220     if (op.bytes >= 19 && !memcmp(op.packet, "OpusHead", 8)) {
221       ogg_stream_clear(&os);
222       return 1;
223     }
224   }
225   ogg_stream_clear(&os);
226   return 0;
227 }
228
229 /* helper, write out available ogg pages */
230 int ogg_write(state *params)
231 {
232   ogg_page page;
233   size_t written;
234
235   if (!params || !params->stream || !params->out) {
236     return -1;
237   }
238
239   while (ogg_stream_pageout(params->stream, &page)) {
240     written = fwrite(page.header, 1, page.header_len, params->out);
241     if (written != (size_t)page.header_len) {
242       fprintf(stderr, "Error writing Ogg page header\n");
243       return -2;
244     }
245     written = fwrite(page.body, 1, page.body_len, params->out);
246     if (written != (size_t)page.body_len) {
247       fprintf(stderr, "Error writing Ogg page body\n");
248       return -3;
249     }
250   }
251
252   return 0;
253 }
254
255 /* helper, flush remaining ogg data */
256 int ogg_flush(state *params)
257 {
258   ogg_page page;
259   size_t written;
260
261   if (!params || !params->stream || !params->out) {
262     return -1;
263   }
264
265   while (ogg_stream_flush(params->stream, &page)) {
266     written = fwrite(page.header, 1, page.header_len, params->out);
267     if (written != (size_t)page.header_len) {
268       fprintf(stderr, "Error writing Ogg page header\n");
269       return -2;
270     }
271     written = fwrite(page.body, 1, page.body_len, params->out);
272     if (written != (size_t)page.body_len) {
273       fprintf(stderr, "Error writing Ogg page body\n");
274       return -3;
275     }
276   }
277
278   return 0;
279 }
280
281 #define ETH_HEADER_LEN 14
282 typedef struct {
283   unsigned char src[6], dst[6]; /* ethernet MACs */
284   int type;
285 } eth_header;
286
287 #define LOOP_HEADER_LEN 4
288 typedef struct {
289   int family;
290 } loop_header;
291
292 #define IP_HEADER_MIN 20
293 typedef struct {
294   int version;
295   int header_size;
296   unsigned char src[4], dst[4]; /* ipv4 addrs */
297   int protocol;
298 } ip_header;
299
300 #define UDP_HEADER_LEN 8
301 typedef struct {
302   int src, dst; /* ports */
303   int size, checksum;
304 } udp_header;
305
306 #define RTP_HEADER_MIN 12
307 typedef struct {
308   int version;
309   int type;
310   int pad, ext, cc, mark;
311   int seq, time;
312   int ssrc;
313   int *csrc;
314   int header_size;
315   int payload_size;
316 } rtp_header;
317
318 /* helper, read a big-endian 16 bit int from memory */
319 static int rbe16(const unsigned char *p)
320 {
321   int v = p[0] << 8 | p[1];
322   return v;
323 }
324
325 /* helper, read a big-endian 32 bit int from memory */
326 static int rbe32(const unsigned char *p)
327 {
328   int v = p[0] << 24 | p[1] << 16 | p[2] << 8 | p[3];
329   return v;
330 }
331
332 /* helper, read a native-endian 32 bit int from memory */
333 static int rne32(const unsigned char *p)
334 {
335   /* On x86 we could just cast, but that might not meet
336    * arm alignment requirements. */
337   int d = 0;
338   memcpy(&d, p, 4);
339   return d;
340 }
341
342 int parse_eth_header(const unsigned char *packet, int size, eth_header *eth)
343 {
344   if (!packet || !eth) {
345     return -2;
346   }
347   if (size < ETH_HEADER_LEN) {
348     fprintf(stderr, "Packet too short for eth\n");
349     return -1;
350   }
351   memcpy(eth->src, packet + 0, 6);
352   memcpy(eth->dst, packet + 6, 6);
353   eth->type = rbe16(packet + 12);
354
355   return 0;
356 }
357
358 /* used by the darwin loopback interface, at least */
359 int parse_loop_header(const unsigned char *packet, int size, loop_header *loop)
360 {
361   if (!packet || !loop) {
362     return -2;
363   }
364   if (size < LOOP_HEADER_LEN) {
365     fprintf(stderr, "Packet too short for loopback\n");
366     return -1;
367   }
368   /* protocol is in host byte order on osx. may be big endian on openbsd? */
369   loop->family = rne32(packet);
370
371   return 0;
372 }
373
374 int parse_ip_header(const unsigned char *packet, int size, ip_header *ip)
375 {
376   if (!packet || !ip) {
377     return -2;
378   }
379   if (size < IP_HEADER_MIN) {
380     fprintf(stderr, "Packet too short for ip\n");
381     return -1;
382   }
383
384   ip->version = (packet[0] >> 4) & 0x0f;
385   if (ip->version != 4) {
386     fprintf(stderr, "unhandled ip version %d\n", ip->version);
387     return 1;
388   }
389
390   /* ipv4 header */
391   ip->header_size = 4 * (packet[0] & 0x0f);
392   ip->protocol = packet[9];
393   memcpy(ip->src, packet + 12, 4);
394   memcpy(ip->dst, packet + 16, 4);
395
396   if (size < ip->header_size) {
397     fprintf(stderr, "Packet too short for ipv4 with options\n");
398     return -1;
399   }
400
401   return 0;
402 }
403
404 int parse_udp_header(const unsigned char *packet, int size, udp_header *udp)
405 {
406   if (!packet || !udp) {
407     return -2;
408   }
409   if (size < UDP_HEADER_LEN) {
410     fprintf(stderr, "Packet too short for udp\n");
411     return -1;
412   }
413
414   udp->src = rbe16(packet);
415   udp->dst = rbe16(packet + 2);
416   udp->size = rbe16(packet + 4);
417   udp->checksum = rbe16(packet + 6);
418
419   return 0;
420 }
421
422
423 int parse_rtp_header(const unsigned char *packet, int size, rtp_header *rtp)
424 {
425   if (!packet || !rtp) {
426     return -2;
427   }
428   if (size < RTP_HEADER_MIN) {
429     fprintf(stderr, "Packet too short for rtp\n");
430     return -1;
431   }
432   rtp->version = (packet[0] >> 6) & 3;
433   rtp->pad = (packet[0] >> 5) & 1;
434   rtp->ext = (packet[0] >> 4) & 1;
435   rtp->cc = packet[0] & 7;
436   rtp->header_size = 12 + 4 * rtp->cc;
437   if (rtp->ext == 1) {
438     uint16_t ext_length;
439     rtp->header_size += 4;
440     ext_length = rbe16(packet + rtp->header_size - 2);
441     rtp->header_size += ext_length * 4;
442   }
443   rtp->payload_size = size - rtp->header_size;
444
445   rtp->mark = (packet[1] >> 7) & 1;
446   rtp->type = (packet[1]) & 127;
447   rtp->seq  = rbe16(packet + 2);
448   rtp->time = rbe32(packet + 4);
449   rtp->ssrc = rbe32(packet + 8);
450   rtp->csrc = NULL;
451   if (size < rtp->header_size) {
452     fprintf(stderr, "Packet too short for RTP header\n");
453     return -1;
454   }
455
456   return 0;
457 }
458
459 int serialize_rtp_header(unsigned char *packet, int size, rtp_header *rtp)
460 {
461   int i;
462
463   if (!packet || !rtp) {
464     return -2;
465   }
466   if (size < RTP_HEADER_MIN) {
467     fprintf(stderr, "Packet buffer too short for RTP\n");
468     return -1;
469   }
470   if (size < rtp->header_size) {
471     fprintf(stderr, "Packet buffer too short for declared RTP header size\n");
472     return -3;
473   }
474   packet[0] = ((rtp->version & 3) << 6) |
475               ((rtp->pad & 1) << 5) |
476               ((rtp->ext & 1) << 4) |
477               ((rtp->cc & 7));
478   packet[1] = ((rtp->mark & 1) << 7) |
479               ((rtp->type & 127));
480   be16(packet+2, rtp->seq);
481   be32(packet+4, rtp->time);
482   be32(packet+8, rtp->ssrc);
483   if (rtp->cc && rtp->csrc) {
484     for (i = 0; i < rtp->cc; i++) {
485       be32(packet + 12 + i*4, rtp->csrc[i]);
486     }
487   }
488
489   return 0;
490 }
491
492 int update_rtp_header(rtp_header *rtp)
493 {
494   rtp->header_size = 12 + 4 * rtp->cc;
495   return 0;
496 }
497
498 #ifndef _WIN32
499 /*
500  * Wait for the next time slot, which begins delta nanoseconds after the
501  * start of the previous time slot, or in the case of the first call at
502  * the time of the call.  delta must be in the range 0..999999999.
503  */
504 void wait_for_time_slot(int delta)
505 {
506 # if defined HAVE_MACH_ABSOLUTE_TIME
507   /* Apple */
508   static mach_timebase_info_data_t tbinfo;
509   static uint64_t target;
510
511   if (tbinfo.numer == 0) {
512     mach_timebase_info(&tbinfo);
513     target = mach_absolute_time();
514   } else {
515     target += tbinfo.numer == tbinfo.denom
516       ? (uint64_t)delta : (uint64_t)delta * tbinfo.denom / tbinfo.numer;
517     mach_wait_until(target);
518   }
519 # elif defined HAVE_CLOCK_GETTIME && defined CLOCK_REALTIME && \
520        defined HAVE_NANOSLEEP
521   /* try to use POSIX monotonic clock */
522   static int initialized = 0;
523   static clockid_t clock_id;
524   static struct timespec target;
525
526   if (!initialized) {
527 #  if defined CLOCK_MONOTONIC && \
528       defined _POSIX_MONOTONIC_CLOCK && _POSIX_MONOTONIC_CLOCK >= 0
529     if (
530 #   if _POSIX_MONOTONIC_CLOCK == 0
531         sysconf(_SC_MONOTONIC_CLOCK) > 0 &&
532 #   endif
533         clock_gettime(CLOCK_MONOTONIC, &target) == 0) {
534       clock_id = CLOCK_MONOTONIC;
535       initialized = 1;
536     } else
537 #  endif
538     if (clock_gettime(CLOCK_REALTIME, &target) == 0) {
539       clock_id = CLOCK_REALTIME;
540       initialized = 1;
541     }
542   } else {
543     target.tv_nsec += delta;
544     if (target.tv_nsec >= 1000000000) {
545       ++target.tv_sec;
546       target.tv_nsec -= 1000000000;
547     }
548 #  if defined HAVE_CLOCK_NANOSLEEP && \
549       defined _POSIX_CLOCK_SELECTION && _POSIX_CLOCK_SELECTION > 0
550     clock_nanosleep(clock_id, TIMER_ABSTIME, &target, NULL);
551 #  else
552     {
553       /* convert to relative time */
554       struct timespec rel;
555       if (clock_gettime(clock_id, &rel) == 0) {
556         rel.tv_sec = target.tv_sec - rel.tv_sec;
557         rel.tv_nsec = target.tv_nsec - rel.tv_nsec;
558         if (rel.tv_nsec < 0) {
559           rel.tv_nsec += 1000000000;
560           --rel.tv_sec;
561         }
562         if (rel.tv_sec >= 0 && (rel.tv_sec > 0 || rel.tv_nsec > 0)) {
563           nanosleep(&rel, NULL);
564         }
565       }
566     }
567 #  endif
568   }
569 # else
570   /* fall back to the old non-monotonic gettimeofday() */
571   static int initialized = 0;
572   static struct timeval target;
573   struct timeval now;
574   int nap;
575
576   if (!initialized) {
577     gettimeofday(&target, NULL);
578     initialized = 1;
579   } else {
580     delta /= 1000;
581     target.tv_usec += delta;
582     if (target.tv_usec >= 1000000) {
583       ++target.tv_sec;
584       target.tv_usec -= 1000000;
585     }
586
587     gettimeofday(&now, NULL);
588     nap = target.tv_usec - now.tv_usec;
589     if (now.tv_sec != target.tv_sec) {
590       if (now.tv_sec > target.tv_sec) nap = 0;
591       else if (target.tv_sec - now.tv_sec == 1) nap += 1000000;
592       else nap = 1000000;
593     }
594     if (nap > delta) nap = delta;
595     if (nap > 0) {
596 #  if defined HAVE_USLEEP
597       usleep(nap);
598 #  else
599       struct timeval timeout;
600       timeout.tv_sec = 0;
601       timeout.tv_usec = nap;
602       select(0, NULL, NULL, NULL, &timeout);
603 #  endif
604     }
605   }
606 # endif
607 }
608
609 int send_rtp_packet(int fd, struct sockaddr *sin,
610     rtp_header *rtp, const unsigned char *opus)
611 {
612   unsigned char *packet;
613   int ret;
614
615   update_rtp_header(rtp);
616   packet = malloc(rtp->header_size + rtp->payload_size);
617   if (!packet) {
618     fprintf(stderr, "Couldn't allocate packet buffer\n");
619     return -1;
620   }
621   serialize_rtp_header(packet, rtp->header_size, rtp);
622   memcpy(packet + rtp->header_size, opus, rtp->payload_size);
623   ret = sendto(fd, packet, rtp->header_size + rtp->payload_size, 0,
624       sin, sizeof(*sin));
625   if (ret < 0) {
626     fprintf(stderr, "error sending: %s\n", strerror(errno));
627   }
628   free(packet);
629
630   return ret;
631 }
632
633 int rtp_send_file(const char *filename, const char *dest, int port,
634         int payload_type)
635 {
636   rtp_header rtp;
637   int fd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
638   struct sockaddr_in sin;
639   int optval = 0;
640   int ret;
641   FILE *in;
642   ogg_sync_state oy;
643   ogg_stream_state os;
644   ogg_page og;
645   ogg_packet op;
646   int headers = 0;
647   char *in_data;
648   const long in_size = 8192;
649   size_t in_read;
650
651   if (fd < 0) {
652     fprintf(stderr, "Couldn't create socket\n");
653     return fd;
654   }
655   sin.sin_family = AF_INET;
656   sin.sin_port = htons(port);
657   if ((sin.sin_addr.s_addr = inet_addr(dest)) == INADDR_NONE) {
658     fprintf(stderr, "Invalid address %s\n", dest);
659     return -1;
660   }
661
662   ret = setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(int));
663   if (ret < 0) {
664     fprintf(stderr, "Couldn't set socket options\n");
665     return ret;
666   }
667
668   rtp.version = 2;
669   rtp.type = payload_type;
670   rtp.pad = 0;
671   rtp.ext = 0;
672   rtp.cc = 0;
673   rtp.mark = 0;
674   rtp.seq = rand();
675   rtp.time = rand();
676   rtp.ssrc = rand();
677   rtp.csrc = NULL;
678   rtp.header_size = 0;
679   rtp.payload_size = 0;
680
681   fprintf(stderr, "Sending %s...\n", filename);
682   in = fopen(filename, "rb");
683
684   if (!in) {
685     fprintf(stderr, "Couldn't open input file '%s'\n", filename);
686     return -1;
687   }
688   ret = ogg_sync_init(&oy);
689   if (ret < 0) {
690     fprintf(stderr, "Couldn't initialize Ogg sync state\n");
691     fclose(in);
692     return ret;
693   }
694   while (!feof(in)) {
695     in_data = ogg_sync_buffer(&oy, in_size);
696     if (!in_data) {
697       fprintf(stderr, "ogg_sync_buffer failed\n");
698       fclose(in);
699       return -1;
700     }
701     in_read = fread(in_data, 1, in_size, in);
702     ret = ogg_sync_wrote(&oy, in_read);
703     if (ret < 0) {
704       fprintf(stderr, "ogg_sync_wrote failed\n");
705       fclose(in);
706       return ret;
707     }
708     while (ogg_sync_pageout(&oy, &og) == 1) {
709       if (headers == 0) {
710         if (is_opus(&og)) {
711           /* this is the start of an Opus stream */
712           ret = ogg_stream_init(&os, ogg_page_serialno(&og));
713           if (ret < 0) {
714             fprintf(stderr, "ogg_stream_init failed\n");
715             fclose(in);
716             return ret;
717           }
718           headers++;
719         } else if (!ogg_page_bos(&og)) {
720           /* We're past the header and haven't found an Opus stream.
721            * Time to give up. */
722           fclose(in);
723           return 1;
724         } else {
725           /* try again */
726           continue;
727         }
728       }
729       /* submit the page for packetization */
730       ret = ogg_stream_pagein(&os, &og);
731       if (ret < 0) {
732         fprintf(stderr, "ogg_stream_pagein failed\n");
733         fclose(in);
734         return ret;
735       }
736       /* read and process available packets */
737       while (ogg_stream_packetout(&os,&op) == 1) {
738         int samples;
739         /* skip header packets */
740         if (headers == 1 && op.bytes >= 19 && !memcmp(op.packet, "OpusHead", 8)) {
741           headers++;
742           continue;
743         }
744         if (headers == 2 && op.bytes >= 16 && !memcmp(op.packet, "OpusTags", 8)) {
745           headers++;
746           continue;
747         }
748         /* get packet duration */
749         samples = opus_packet_get_nb_samples(op.packet, op.bytes, 48000);
750         if (samples <= 0) {
751           fprintf(stderr, "skipping invalid packet\n");
752           continue;
753         }
754         /* update the rtp header and send */
755         rtp.seq++;
756         rtp.time += samples;
757         rtp.payload_size = op.bytes;
758         fprintf(stderr, "rtp %d %d %d %3d ms %5d bytes\n",
759             rtp.type, rtp.seq, rtp.time, samples/48, rtp.payload_size);
760         send_rtp_packet(fd, (struct sockaddr *)&sin, &rtp, op.packet);
761         /* convert number of 48 kHz samples to nanoseconds without overflow */
762         wait_for_time_slot(samples*62500/3);
763       }
764     }
765   }
766
767   if (headers > 0)
768     ogg_stream_clear(&os);
769   ogg_sync_clear(&oy);
770   fclose(in);
771   return 0;
772 }
773 #else /* _WIN32 */
774 int rtp_send_file(const char *filename, const char *dest, int port,
775         int payload_type)
776 {
777   fprintf(stderr, "Cannot send '%s to %s:%d'. Socket support not available.\n",
778           filename, dest, port);
779   (void)payload_type;
780   return -2;
781 }
782 #endif
783
784
785 #ifdef HAVE_PCAP
786 /* pcap 'got_packet' callback */
787 void write_packet(u_char *args, const struct pcap_pkthdr *header,
788                   const u_char *data)
789 {
790   state *params = (state *)(void *)args;
791   const unsigned char *packet;
792   int size;
793   eth_header eth;
794   loop_header loop;
795   ip_header ip;
796   udp_header udp;
797   rtp_header rtp;
798   ogg_packet *op;
799   int samples;
800
801   fprintf(stderr, "Got %d byte packet (%d bytes captured)\n",
802           header->len, header->caplen);
803   packet = data;
804   size = header->caplen;
805
806   /* parse the link-layer header */
807   switch (params->linktype) {
808     case DLT_EN10MB:
809       if (parse_eth_header(packet, size, &eth)) {
810         fprintf(stderr, "error parsing eth header\n");
811         return;
812       }
813       fprintf(stderr, "  eth 0x%04x", eth.type);
814       fprintf(stderr, " %02x:%02x:%02x:%02x:%02x:%02x ->",
815               eth.src[0], eth.src[1], eth.src[2],
816               eth.src[3], eth.src[4], eth.src[5]);
817       fprintf(stderr, " %02x:%02x:%02x:%02x:%02x:%02x\n",
818               eth.dst[0], eth.dst[1], eth.dst[2],
819               eth.dst[3], eth.dst[4], eth.dst[5]);
820       if (eth.type != 0x0800) {
821         fprintf(stderr, "skipping packet: no IPv4\n");
822         return;
823       }
824       packet += ETH_HEADER_LEN;
825       size -= ETH_HEADER_LEN;
826       break;
827     case DLT_NULL:
828       if (parse_loop_header(packet, size, &loop)) {
829         fprintf(stderr, "error parsing loopback header\n");
830         return;
831       }
832       fprintf(stderr, " loopback family %d\n", loop.family);
833       if (loop.family != PF_INET) {
834         fprintf(stderr, "skipping packet: not IP\n");
835         return;
836       }
837       packet += LOOP_HEADER_LEN;
838       size -= LOOP_HEADER_LEN;
839       break;
840     default:
841       fprintf(stderr, "skipping packet: unrecognized linktype %d\n",
842           params->linktype);
843       return;
844   }
845
846   if (parse_ip_header(packet, size, &ip)) {
847     fprintf(stderr, "error parsing ip header\n");
848     return;
849   }
850   fprintf(stderr, " ipv%d protocol %d", ip.version, ip.protocol);
851   fprintf(stderr, " %d.%d.%d.%d ->",
852           ip.src[0], ip.src[1], ip.src[2], ip.src[3]);
853   fprintf(stderr, " %d.%d.%d.%d",
854           ip.dst[0], ip.dst[1], ip.dst[2], ip.dst[3]);
855   fprintf(stderr, " header %d bytes\n", ip.header_size);
856   if (ip.protocol != 17) {
857     fprintf(stderr, "skipping packet: not UDP\n");
858     return;
859   }
860   packet += ip.header_size;
861   size -= ip.header_size;
862
863   if (parse_udp_header(packet, size, &udp)) {
864     fprintf(stderr, "error parsing udp header\n");
865     return;
866   }
867   fprintf(stderr, "  udp %d bytes %d -> %d crc 0x%04x\n",
868           udp.size, udp.src, udp.dst, udp.checksum);
869   packet += UDP_HEADER_LEN;
870   size -= UDP_HEADER_LEN;
871
872   if (parse_rtp_header(packet, size, &rtp)) {
873     fprintf(stderr, "error parsing rtp header\n");
874     return;
875   }
876   fprintf(stderr, "  rtp 0x%08x %d %d %d",
877           rtp.ssrc, rtp.type, rtp.seq, rtp.time);
878   fprintf(stderr, "  v%d %s%s%s CC %d", rtp.version,
879           rtp.pad ? "P":".", rtp.ext ? "X":".",
880           rtp.mark ? "M":".", rtp.cc);
881   fprintf(stderr, " %5d bytes\n", rtp.payload_size);
882
883   if (!params->out) {
884     return;
885   }
886
887   packet += rtp.header_size;
888   size -= rtp.header_size;
889
890   if (size < 0) {
891     fprintf(stderr, "skipping short packet\n");
892     return;
893   }
894
895   if (rtp.seq < params->seq) {
896     fprintf(stderr, "skipping out-of-sequence packet\n");
897     return;
898   }
899   params->seq = rtp.seq;
900
901   /* look for first plausible payload_type if no payload type specified */
902   if (params->payload_type < 0 && rtp.type >= DYNAMIC_PAYLOAD_TYPE_MIN) {
903     const unsigned char *frames[48];
904     opus_int16 fsizes[48];
905     if (opus_packet_parse(packet, size, NULL, frames, fsizes, NULL) > 0) {
906       /* this could be a valid Opus packet */
907       fprintf(stderr, "recording stream with payload type %d\n", rtp.type);
908       params->payload_type = rtp.type;
909     }
910   }
911
912   if (rtp.type != params->payload_type) {
913     fprintf(stderr, "skipping packet with payload type %d\n", rtp.type);
914     return;
915   }
916
917   /* write the payload to our opus file */
918   op = op_from_pkt(packet, size);
919   op->packetno = rtp.seq;
920   samples = opus_packet_get_nb_samples(packet, size, 48000);
921   if (samples > 0) params->granulepos += samples;
922   op->granulepos = params->granulepos;
923   ogg_stream_packetin(params->stream, op);
924   free(op);
925   ogg_write(params);
926
927   if (size < rtp.payload_size) {
928     fprintf(stderr, "!! truncated %d uncaptured bytes\n",
929             rtp.payload_size - size);
930   } else if (samples <= 0) {
931     fprintf(stderr, "!! invalid opus packet\n");
932   }
933 }
934
935 /* use libpcap to capture packets and write them to a file */
936 int sniff(const char *input_file, const char *output_file, int payload_type,
937         int samplerate, int channels)
938 {
939   state *params;
940   pcap_t *pcap;
941   char errbuf[PCAP_ERRBUF_SIZE];
942   ogg_packet *op;
943
944   /* set up */
945   if (input_file) {
946     pcap = pcap_open_offline(input_file, errbuf);
947     if (pcap == NULL) {
948       fprintf(stderr,"Cannot open pcap file: %s\n%s\n", input_file, errbuf);
949       return 1;
950     }
951   } else {
952     pcap = pcap_open_live(SNIFF_DEVICE, 9600, 0, 1000, errbuf);
953     if (pcap == NULL) {
954       fprintf(stderr, "Cannot open device %s\n%s\n", SNIFF_DEVICE, errbuf);
955       return 1;
956     }
957   }
958
959   params = malloc(sizeof(state));
960   if (!params) {
961     fprintf(stderr, "Couldn't allocate param struct.\n");
962     pcap_close(pcap);
963     return 1;
964   }
965   params->linktype = pcap_datalink(pcap);
966   params->stream = malloc(sizeof(ogg_stream_state));
967   if (!params->stream) {
968     fprintf(stderr, "Couldn't allocate stream struct.\n");
969     free(params);
970     pcap_close(pcap);
971     return 1;
972   }
973   if (ogg_stream_init(params->stream, rand()) < 0) {
974     fprintf(stderr, "Couldn't initialize Ogg stream state.\n");
975     free(params->stream);
976     free(params);
977     pcap_close(pcap);
978     return 1;
979   }
980   params->out = NULL;
981   params->seq = 0;
982   params->granulepos = 0;
983   params->payload_type = payload_type;
984
985   if (output_file) {
986     if (strcmp(output_file, "-") == 0) {
987       params->out = stdout;
988     } else {
989       params->out = fopen(output_file, "wb");
990     }
991     if (!params->out) {
992       fprintf(stderr, "Couldn't open output file.\n");
993       free(params->stream);
994       free(params);
995       pcap_close(pcap);
996       return 1;
997     }
998     /* write stream headers */
999     op = op_opushead(samplerate, channels);
1000     ogg_stream_packetin(params->stream, op);
1001     op_free(op);
1002     op = op_opustags();
1003     ogg_stream_packetin(params->stream, op);
1004     op_free(op);
1005     ogg_flush(params);
1006   }
1007
1008   /* start capture loop */
1009   /* if reading from an input file, continue until EOF */
1010   fprintf(stderr, "Capturing packets\n");
1011   pcap_loop(pcap, input_file ? 0 : 300, write_packet, (u_char *)params);
1012
1013   /* write outstanding data */
1014   if (params->out) {
1015     ogg_flush(params);
1016     if (params->out == stdout) {
1017       fflush(stdout);
1018     } else {
1019       fclose(params->out);
1020     }
1021     params->out = NULL;
1022   }
1023
1024   /* clean up */
1025   ogg_stream_destroy(params->stream);
1026   free(params);
1027   pcap_close(pcap);
1028   return 0;
1029 }
1030 #endif /* HAVE_PCAP */
1031
1032 void opustools_version(void)
1033 {
1034   printf("opusrtp %s %s\n", PACKAGE_NAME, PACKAGE_VERSION);
1035   printf("Copyright (C) 2012-2018 Xiph.Org Foundation\n");
1036 }
1037
1038 void usage(char *exe)
1039 {
1040   printf("Usage: %s [--extract file.pcap] [--sniff] <file.opus> [<file2.opus>]\n", exe);
1041   printf("\n");
1042   printf("Sends and receives Opus audio RTP streams.\n");
1043   printf("\nGeneral Options:\n");
1044   printf(" -h, --help             Show this help\n");
1045   printf(" -V, --version          Show version information\n");
1046   printf(" -q, --quiet            Suppress status output\n");
1047   printf(" -d, --destination addr Set destination IP address (default 127.0.0.1)\n");
1048   printf(" -p, --port n           Set destination port (default 1234)\n");
1049   printf(" -o, --output out.opus  Write Ogg Opus output file\n");
1050   printf(" -r, --rate n           Set output file sample rate (default 48000)\n");
1051   printf(" -c, --channels n       Set output file channel count (default 2)\n");
1052   printf(" -t, --type n           Set RTP payload type (default 120)\n");
1053   printf(" --sniff                Sniff loopback interface for Opus RTP streams\n");
1054   printf(" -e, --extract in.pcap  Extract from input pcap file\n");
1055   printf("\n");
1056   printf("By default, the given file(s) will be sent over RTP.\n");
1057 }
1058
1059 int main(int argc, char *argv[])
1060 {
1061   int option, i;
1062   const char *dest = "127.0.0.1";
1063   const char *input_pcap = NULL;
1064   const char *output_file = NULL;
1065   int pcap_mode = 0;
1066   int port = 1234;
1067   int payload_type = -1;
1068   int samplerate = 48000;
1069   int channels = 2;
1070   struct option long_options[] = {
1071     {"help", no_argument, NULL, 'h'},
1072     {"version", no_argument, NULL, 'V'},
1073     {"quiet", no_argument, NULL, 'q'},
1074     {"output", required_argument, NULL, 'o'},
1075     {"destination", required_argument, NULL, 'd'},
1076     {"port", required_argument, NULL, 'p'},
1077     {"rate", required_argument, NULL, 'r'},
1078     {"channels", required_argument, NULL, 'c'},
1079     {"type", required_argument, NULL, 't'},
1080     {"sniff", no_argument, NULL, 0},
1081     {"extract", required_argument, NULL, 'e'},
1082     {0, 0, 0, 0}
1083   };
1084
1085   /* process command line arguments */
1086   while ((option = getopt_long(argc, argv, "hVqo:d:p:r:c:t:e:",
1087             long_options, &i)) != -1) {
1088     switch (option) {
1089       case 0:
1090         if (!strcmp(long_options[i].name, "sniff")) {
1091           pcap_mode = 1;
1092         } else {
1093           fprintf(stderr, "Unknown option - try %s --help.\n", argv[0]);
1094           return -1;
1095         }
1096         break;
1097       case 'V':
1098         opustools_version();
1099         return 0;
1100       case 'q':
1101         break;
1102       case 'o':
1103         if (optarg)
1104             output_file = optarg;
1105         break;
1106       case 'd':
1107         if (optarg)
1108             dest = optarg;
1109         break;
1110       case 'e':
1111         if (optarg) {
1112             input_pcap = optarg;
1113             pcap_mode = 1;
1114         }
1115         break;
1116       case 'p':
1117         if (optarg)
1118             port = atoi(optarg);
1119         break;
1120       case 'r':
1121         if (optarg)
1122             samplerate = atoi(optarg);
1123         break;
1124       case 'c':
1125         if (optarg)
1126             channels = atoi(optarg);
1127         break;
1128       case 't':
1129         if (optarg)
1130             payload_type = atoi(optarg);
1131         break;
1132       case 'h':
1133         usage(argv[0]);
1134         return 0;
1135       case '?':
1136       default:
1137         usage(argv[0]);
1138         return 1;
1139     }
1140   }
1141
1142   if (optind < argc) {
1143     /* files to transmit were specified */
1144     if (pcap_mode) {
1145       fprintf(stderr, "Ogg Opus input files cannot be used with %s.\n",
1146         input_pcap ? "--extract" : "--sniff");
1147       return 1;
1148     }
1149     if (payload_type < 0) payload_type = 120;
1150     for (i = optind; i < argc; i++) {
1151       rtp_send_file(argv[i], dest, port, payload_type);
1152     }
1153     return 0;
1154   }
1155
1156   if (pcap_mode) {
1157 #ifdef HAVE_PCAP
1158     return sniff(input_pcap, output_file, payload_type, samplerate, channels);
1159 #else
1160     (void)input_pcap;
1161     (void)output_file;
1162     (void)samplerate;
1163     (void)channels;
1164     fprintf(stderr, "Sorry, pcap support is disabled.\n");
1165     return 1;
1166 #endif
1167   }
1168
1169   usage(argv[0]);
1170   return 1;
1171 }