From 8893281e3d3edb32fbe9153c4cdfc3db8c719797 Mon Sep 17 00:00:00 2001 From: Richard Fuchs Date: Wed, 2 Aug 2023 08:51:32 -0400 Subject: [PATCH] MT#55283 switch to anonymous unions Change-Id: If80137ba4955013bb2b919c5bec9172a9776374e --- daemon/homer.c | 8 +- daemon/iptables.c | 4 +- daemon/log.c | 76 ++++----- daemon/log.h | 4 +- daemon/log_funcs.h | 24 +-- daemon/main.c | 8 +- daemon/recording.c | 154 +++++++++---------- daemon/rtcp.c | 28 ++-- daemon/sdp.c | 224 +++++++++++++-------------- daemon/stun.c | 20 +-- include/call.h | 2 +- include/recording.h | 4 +- lib/codeclib.c | 316 +++++++++++++++++++------------------- lib/codeclib.h | 10 +- lib/socket.c | 66 ++++---- lib/socket.h | 4 +- recording-daemon/output.c | 10 +- t/Makefile | 2 +- 18 files changed, 482 insertions(+), 482 deletions(-) diff --git a/daemon/homer.c b/daemon/homer.c index 8ea17ff7f..e38c8178c 100644 --- a/daemon/homer.c +++ b/daemon/homer.c @@ -363,13 +363,13 @@ static int send_hepv3 (GString *s, const str *id, int capt_id, const endpoint_t /* SRC IP */ src_ip4.chunk.vendor_id = htons(0x0000); src_ip4.chunk.type_id = htons(0x0003); - src_ip4.data = src->address.u.ipv4; + src_ip4.data = src->address.ipv4; src_ip4.chunk.length = htons(sizeof(src_ip4)); /* DST IP */ dst_ip4.chunk.vendor_id = htons(0x0000); dst_ip4.chunk.type_id = htons(0x0004); - dst_ip4.data = dst->address.u.ipv4; + dst_ip4.data = dst->address.ipv4; dst_ip4.chunk.length = htons(sizeof(dst_ip4)); iplen = sizeof(dst_ip4) + sizeof(src_ip4); @@ -379,13 +379,13 @@ static int send_hepv3 (GString *s, const str *id, int capt_id, const endpoint_t /* SRC IPv6 */ src_ip6.chunk.vendor_id = htons(0x0000); src_ip6.chunk.type_id = htons(0x0005); - src_ip6.data = src->address.u.ipv6; + src_ip6.data = src->address.ipv6; src_ip6.chunk.length = htons(sizeof(src_ip6)); /* DST IPv6 */ dst_ip6.chunk.vendor_id = htons(0x0000); dst_ip6.chunk.type_id = htons(0x0006); - dst_ip6.data = dst->address.u.ipv6; + dst_ip6.data = dst->address.ipv6; dst_ip6.chunk.length = htons(sizeof(dst_ip6)); iplen = sizeof(dst_ip6) + sizeof(src_ip6); diff --git a/daemon/iptables.c b/daemon/iptables.c index 6e5f45563..753e2629c 100644 --- a/daemon/iptables.c +++ b/daemon/iptables.c @@ -103,7 +103,7 @@ static void ip46tables_fill_matches(struct ipt_matches *matches, const socket_t static void ip4_fill_entry(struct ipv4_ipt_entry *entry, const socket_t *local_sock, const str *comment) { ZERO(*entry); entry->entry.ip.proto = IPPROTO_UDP; - entry->entry.ip.dst = local_sock->local.address.u.ipv4; + entry->entry.ip.dst = local_sock->local.address.ipv4; memset(&entry->entry.ip.dmsk, 0xff, sizeof(entry->entry.ip.dmsk)); entry->entry.target_offset = G_STRUCT_OFFSET(struct ipv4_ipt_entry, matches.target); @@ -114,7 +114,7 @@ static void ip4_fill_entry(struct ipv4_ipt_entry *entry, const socket_t *local_s static void ip6_fill_entry(struct ipv6_ipt_entry *entry, const socket_t *local_sock, const str *comment) { ZERO(*entry); entry->entry.ipv6.proto = IPPROTO_UDP; - entry->entry.ipv6.dst = local_sock->local.address.u.ipv6; + entry->entry.ipv6.dst = local_sock->local.address.ipv6; entry->entry.ipv6.flags |= IP6T_F_PROTO; memset(&entry->entry.ipv6.dmsk, 0xff, sizeof(entry->entry.ipv6.dmsk)); entry->entry.target_offset = G_STRUCT_OFFSET(struct ipv6_ipt_entry, matches.target); diff --git a/daemon/log.c b/daemon/log.c index 55d0ff89f..8b33da171 100644 --- a/daemon/log.c +++ b/daemon/log.c @@ -41,45 +41,45 @@ static void ilog_prefix_default(char *prefix, size_t prefix_len) { break; case LOG_INFO_CALL: snprintf(prefix, prefix_len, "[" STR_FORMAT_M "]: ", - STR_FMT_M(&log_info.u.call->callid)); + STR_FMT_M(&log_info.call->callid)); break; case LOG_INFO_STREAM_FD: - if (log_info.u.stream_fd->call) { - if (log_info.u.stream_fd->stream) + if (log_info.stream_fd->call) { + if (log_info.stream_fd->stream) snprintf(prefix, prefix_len, "[" STR_FORMAT_M "/" STR_FORMAT_M "/%u port %5u]: ", - STR_FMT_M(&log_info.u.stream_fd->call->callid), - STR_FMT_M(&log_info.u.stream_fd->stream->media->monologue->tag), - log_info.u.stream_fd->stream->media->index, - log_info.u.stream_fd->socket.local.port); + STR_FMT_M(&log_info.stream_fd->call->callid), + STR_FMT_M(&log_info.stream_fd->stream->media->monologue->tag), + log_info.stream_fd->stream->media->index, + log_info.stream_fd->socket.local.port); else snprintf(prefix, prefix_len, "[" STR_FORMAT_M " port %5u]: ", - STR_FMT_M(&log_info.u.stream_fd->call->callid), - log_info.u.stream_fd->socket.local.port); + STR_FMT_M(&log_info.stream_fd->call->callid), + log_info.stream_fd->socket.local.port); } else snprintf(prefix, prefix_len, "[no call, port %5u]: ", - log_info.u.stream_fd->socket.local.port); + log_info.stream_fd->socket.local.port); break; case LOG_INFO_STR: snprintf(prefix, prefix_len, "[" STR_FORMAT_M "]: ", - STR_FMT_M(log_info.u.str)); + STR_FMT_M(log_info.str)); break; case LOG_INFO_C_STRING: snprintf(prefix, prefix_len, "[%s%s%s]: ", - FMT_M(log_info.u.cstr)); + FMT_M(log_info.cstr)); break; case LOG_INFO_ICE_AGENT: snprintf(prefix, prefix_len, "[" STR_FORMAT_M "/" STR_FORMAT_M "/%u]: ", - STR_FMT_M(&log_info.u.ice_agent->call->callid), - STR_FMT_M(&log_info.u.ice_agent->media->monologue->tag), - log_info.u.ice_agent->media->index); + STR_FMT_M(&log_info.ice_agent->call->callid), + STR_FMT_M(&log_info.ice_agent->media->monologue->tag), + log_info.ice_agent->media->index); break; case LOG_INFO_MEDIA: snprintf(prefix, prefix_len, "[" STR_FORMAT_M "/" STR_FORMAT_M "/%u]: ", - STR_FMT_M(&log_info.u.call->callid), - STR_FMT_M(&log_info.v.media->monologue->tag), - log_info.v.media->index); + STR_FMT_M(&log_info.call->callid), + STR_FMT_M(&log_info.media->monologue->tag), + log_info.media->index); break; } } @@ -91,40 +91,40 @@ static void ilog_prefix_parsable(char *prefix, size_t prefix_len) { break; case LOG_INFO_CALL: snprintf(prefix, prefix_len, "[ID=\""STR_FORMAT"\"]: ", - STR_FMT(&log_info.u.call->callid)); + STR_FMT(&log_info.call->callid)); break; case LOG_INFO_STREAM_FD: - if (log_info.u.stream_fd->call) { - if (log_info.u.stream_fd->stream) + if (log_info.stream_fd->call) { + if (log_info.stream_fd->stream) snprintf(prefix, prefix_len, "[ID=\""STR_FORMAT"\" tag=\""STR_FORMAT"\" index=\"%u\" port=\"%5u\"]: ", - STR_FMT(&log_info.u.stream_fd->call->callid), - STR_FMT(&log_info.u.stream_fd->stream->media->monologue->tag), - log_info.u.stream_fd->stream->media->index, - log_info.u.stream_fd->socket.local.port); + STR_FMT(&log_info.stream_fd->call->callid), + STR_FMT(&log_info.stream_fd->stream->media->monologue->tag), + log_info.stream_fd->stream->media->index, + log_info.stream_fd->socket.local.port); else snprintf(prefix, prefix_len, "[ID=\""STR_FORMAT"\" port=\"%5u\"]: ", - STR_FMT(&log_info.u.stream_fd->call->callid), - log_info.u.stream_fd->socket.local.port); + STR_FMT(&log_info.stream_fd->call->callid), + log_info.stream_fd->socket.local.port); } break; case LOG_INFO_STR: snprintf(prefix, prefix_len, "[ID=\""STR_FORMAT"\"]: ", - STR_FMT(log_info.u.str)); + STR_FMT(log_info.str)); break; case LOG_INFO_C_STRING: - snprintf(prefix, prefix_len, "[ID=\"%s\"]: ", log_info.u.cstr); + snprintf(prefix, prefix_len, "[ID=\"%s\"]: ", log_info.cstr); break; case LOG_INFO_ICE_AGENT: snprintf(prefix, prefix_len, "[ID=\""STR_FORMAT"\" tag=\""STR_FORMAT"\" index=\"%u\"]: ", - STR_FMT(&log_info.u.ice_agent->call->callid), - STR_FMT(&log_info.u.ice_agent->media->monologue->tag), - log_info.u.ice_agent->media->index); + STR_FMT(&log_info.ice_agent->call->callid), + STR_FMT(&log_info.ice_agent->media->monologue->tag), + log_info.ice_agent->media->index); break; case LOG_INFO_MEDIA: snprintf(prefix, prefix_len, "[ID=\""STR_FORMAT"\" tag=\""STR_FORMAT"\" index=\"%u\"]: ", - STR_FMT(&log_info.u.call->callid), - STR_FMT(&log_info.v.media->monologue->tag), - log_info.v.media->index); + STR_FMT(&log_info.call->callid), + STR_FMT(&log_info.media->monologue->tag), + log_info.media->index); break; } } @@ -171,13 +171,13 @@ int get_local_log_level(unsigned int subsystem_idx) { switch (log_info.e) { case LOG_INFO_CALL: case LOG_INFO_MEDIA: - call = log_info.u.call; + call = log_info.call; break; case LOG_INFO_STREAM_FD: - call = log_info.u.stream_fd->call; + call = log_info.stream_fd->call; break; case LOG_INFO_ICE_AGENT: - call = log_info.u.ice_agent->call; + call = log_info.ice_agent->call; break; default: break; diff --git a/daemon/log.h b/daemon/log.h index 78fcfa4e6..b0e0fa849 100644 --- a/daemon/log.h +++ b/daemon/log.h @@ -20,10 +20,10 @@ struct log_info { const char *cstr; struct ice_agent *ice_agent; void *ptr; - } u; + }; union { struct call_media *media; - } v; + }; enum { LOG_INFO_NONE = 0, LOG_INFO_CALL, diff --git a/daemon/log_funcs.h b/daemon/log_funcs.h index 7c647316a..1b858b817 100644 --- a/daemon/log_funcs.h +++ b/daemon/log_funcs.h @@ -14,13 +14,13 @@ INLINE void __log_info_release(struct log_info *li) { return; case LOG_INFO_CALL: case LOG_INFO_MEDIA: - obj_put(li->u.call); + obj_put(li->call); break; case LOG_INFO_STREAM_FD: - obj_put(li->u.stream_fd); + obj_put(li->stream_fd); break; case LOG_INFO_ICE_AGENT: - obj_put(&li->u.ice_agent->tt_obj); + obj_put(&li->ice_agent->tt_obj); break; case LOG_INFO_STR: case LOG_INFO_C_STRING: @@ -51,8 +51,8 @@ INLINE void log_info_pop(void) { // should be used with non-refcounted log info pieces INLINE void log_info_pop_until(void *p) { assert(p != NULL); - while (log_info.u.ptr) { - void *prev = log_info.u.ptr; + while (log_info.ptr) { + void *prev = log_info.ptr; log_info_pop(); if (prev == p) break; @@ -76,35 +76,35 @@ INLINE void log_info_call(struct call *c) { return; __log_info_push(); log_info.e = LOG_INFO_CALL; - log_info.u.call = obj_get(c); + log_info.call = obj_get(c); } INLINE void log_info_stream_fd(struct stream_fd *sfd) { if (!sfd) return; __log_info_push(); log_info.e = LOG_INFO_STREAM_FD; - log_info.u.stream_fd = obj_get(sfd); + log_info.stream_fd = obj_get(sfd); } INLINE void log_info_str(const str *s) { if (!s || !s->s) return; __log_info_push(); log_info.e = LOG_INFO_STR; - log_info.u.str = s; + log_info.str = s; } INLINE void log_info_c_string(const char *s) { if (!s) return; __log_info_push(); log_info.e = LOG_INFO_C_STRING; - log_info.u.cstr = s; + log_info.cstr = s; } INLINE void log_info_ice_agent(struct ice_agent *ag) { if (!ag) return; __log_info_push(); log_info.e = LOG_INFO_ICE_AGENT; - log_info.u.ice_agent = obj_get(&ag->tt_obj); + log_info.ice_agent = obj_get(&ag->tt_obj); } INLINE void log_info_media(struct call_media *m) { if (!m) @@ -113,8 +113,8 @@ INLINE void log_info_media(struct call_media *m) { return; __log_info_push(); log_info.e = LOG_INFO_MEDIA; - log_info.u.call = obj_get(m->call); - log_info.v.media = m; + log_info.call = obj_get(m->call); + log_info.media = m; } diff --git a/daemon/main.c b/daemon/main.c index e2f1af37f..cb7e64e78 100644 --- a/daemon/main.c +++ b/daemon/main.c @@ -186,7 +186,7 @@ static void __find_if_name(char *s, struct ifaddrs *ifas, GQueue *addrs) { if (ifa->ifa_addr->sa_family == AF_INET) { struct sockaddr_in *sin = (void *) ifa->ifa_addr; addr->family = get_socket_family_enum(SF_IP4); - addr->u.ipv4 = sin->sin_addr; + addr->ipv4 = sin->sin_addr; } else if (ifa->ifa_addr->sa_family == AF_INET6) { struct sockaddr_in6 *sin = (void *) ifa->ifa_addr; @@ -196,7 +196,7 @@ static void __find_if_name(char *s, struct ifaddrs *ifas, GQueue *addrs) { continue; } addr->family = get_socket_family_enum(SF_IP6); - addr->u.ipv6 = sin->sin6_addr; + addr->ipv6 = sin->sin6_addr; } else { g_slice_free1(sizeof(*addr), addr); @@ -230,13 +230,13 @@ static void __resolve_ifname(char *s, GQueue *addrs) { struct sockaddr_in *sin = (void *) r->ai_addr; assert(r->ai_addrlen >= sizeof(*sin)); addr->family = __get_socket_family_enum(SF_IP4); - addr->u.ipv4 = sin->sin_addr; + addr->ipv4 = sin->sin_addr; } else if (r->ai_family == AF_INET6) { struct sockaddr_in6 *sin = (void *) r->ai_addr; assert(r->ai_addrlen >= sizeof(*sin)); addr->family = __get_socket_family_enum(SF_IP6); - addr->u.ipv6 = sin->sin6_addr; + addr->ipv6 = sin->sin6_addr; } else { g_slice_free1(sizeof(*addr), addr); diff --git a/daemon/recording.c b/daemon/recording.c index 490b62bb3..8be745267 100644 --- a/daemon/recording.c +++ b/daemon/recording.c @@ -444,16 +444,16 @@ static void rec_pcap_init(struct call *call) { struct recording *recording = call->recording; // Wireshark starts at packet index 1, so we start there, too - recording->u.pcap.packet_num = 1; - mutex_init(&recording->u.pcap.recording_lock); + recording->pcap.packet_num = 1; + mutex_init(&recording->pcap.recording_lock); meta_setup_file(recording); // set up pcap file char *pcap_path = recording_setup_file(recording); - if (pcap_path != NULL && recording->u.pcap.recording_pdumper != NULL - && recording->u.pcap.meta_fp) { + if (pcap_path != NULL && recording->pcap.recording_pdumper != NULL + && recording->pcap.meta_fp) { // Write the location of the PCAP file to the metadata file - fprintf(recording->u.pcap.meta_fp, "%s\n\n", pcap_path); + fprintf(recording->pcap.meta_fp, "%s\n\n", pcap_path); } } @@ -472,16 +472,16 @@ static char *meta_setup_file(struct recording *recording) { } char *meta_filepath = file_path_str(recording->meta_prefix, "/tmp/rtpengine-meta-", ".tmp"); - recording->u.pcap.meta_filepath = meta_filepath; + recording->pcap.meta_filepath = meta_filepath; FILE *mfp = fopen(meta_filepath, "w"); // coverity[check_return : FALSE] chmod(meta_filepath, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH); if (mfp == NULL) { ilog(LOG_ERROR, "Could not open metadata file: %s%s%s", FMT_M(meta_filepath)); - g_clear_pointer(&recording->u.pcap.meta_filepath, free); + g_clear_pointer(&recording->pcap.meta_filepath, free); return NULL; } - recording->u.pcap.meta_fp = mfp; + recording->pcap.meta_fp = mfp; ilog(LOG_DEBUG, "Wrote metadata file to temporary path: %s%s%s", FMT_M(meta_filepath)); return meta_filepath; } @@ -492,7 +492,7 @@ static char *meta_setup_file(struct recording *recording) { static void sdp_after_pcap(struct recording *recording, GString *s, struct call_monologue *ml, enum call_opmode opmode) { - FILE *meta_fp = recording->u.pcap.meta_fp; + FILE *meta_fp = recording->pcap.meta_fp; if (!meta_fp) return; @@ -507,7 +507,7 @@ static void sdp_after_pcap(struct recording *recording, GString *s, struct call_ fprintf(meta_fp, "%.3lf", ml->started.tv_sec*1000.0+ml->started.tv_usec/1000.0); fprintf(meta_fp, "\nSDP mode: "); fprintf(meta_fp, "%s", get_opmode_text(opmode)); - fprintf(meta_fp, "\nSDP before RTP packet: %" PRIu64 "\n\n", recording->u.pcap.packet_num); + fprintf(meta_fp, "\nSDP before RTP packet: %" PRIu64 "\n\n", recording->pcap.packet_num); fflush(meta_fp); if (write(meta_fd, s->str, s->len) <= 0) ilog(LOG_WARN, "Error writing SDP body to metadata file: %s", strerror(errno)); @@ -520,7 +520,7 @@ static void rec_pcap_meta_finish_file(struct call *call) { // This should usually be called from a place that has the call->master_lock struct recording *recording = call->recording; - if (recording == NULL || recording->u.pcap.meta_fp == NULL) { + if (recording == NULL || recording->pcap.meta_fp == NULL) { ilog(LOG_INFO, "Trying to clean up recording meta file without a file pointer opened."); return; } @@ -533,34 +533,34 @@ static void rec_pcap_meta_finish_file(struct call *call) { struct tm timeinfo; struct timeval *terminate; terminate = &(((struct call_monologue *)call->monologues.head->data)->terminated); - fprintf(recording->u.pcap.meta_fp, "\nTimestamp terminated ms(first monologue): %.3lf", terminate->tv_sec*1000.0 + terminate->tv_usec/1000.0); + fprintf(recording->pcap.meta_fp, "\nTimestamp terminated ms(first monologue): %.3lf", terminate->tv_sec*1000.0 + terminate->tv_usec/1000.0); if (localtime_r(&start, &timeinfo) == NULL) { ilog(LOG_ERROR, "Cannot get start local time, while cleaning up recording meta file: %s", strerror(errno)); } else { strftime(timebuffer, 20, "%FT%T", &timeinfo); - fprintf(recording->u.pcap.meta_fp, "\n\ncall start time: %s\n", timebuffer); + fprintf(recording->pcap.meta_fp, "\n\ncall start time: %s\n", timebuffer); } if (localtime_r(&end, &timeinfo) == NULL) { ilog(LOG_ERROR, "Cannot get end local time, while cleaning up recording meta file: %s", strerror(errno)); } else { strftime(timebuffer, 20, "%FT%T", &timeinfo); - fprintf(recording->u.pcap.meta_fp, "call end time: %s\n", timebuffer); + fprintf(recording->pcap.meta_fp, "call end time: %s\n", timebuffer); } // Print metadata if (call->metadata.len) - fprintf(recording->u.pcap.meta_fp, "\n\n"STR_FORMAT"\n", STR_FMT(&call->metadata)); - fclose(recording->u.pcap.meta_fp); - recording->u.pcap.meta_fp = NULL; + fprintf(recording->pcap.meta_fp, "\n\n"STR_FORMAT"\n", STR_FMT(&call->metadata)); + fclose(recording->pcap.meta_fp); + recording->pcap.meta_fp = NULL; // Get the filename (in between its directory and the file extension) // and move it to the finished file location. // Rename extension to ".txt". int fn_len; - char *meta_filename = strrchr(recording->u.pcap.meta_filepath, '/'); + char *meta_filename = strrchr(recording->pcap.meta_filepath, '/'); char *meta_ext = NULL; if (meta_filename == NULL) { - meta_filename = recording->u.pcap.meta_filepath; + meta_filename = recording->pcap.meta_filepath; } else { meta_filename = meta_filename + 1; @@ -573,17 +573,17 @@ static void rec_pcap_meta_finish_file(struct call *call) { char new_metapath[prefix_len + fn_len + ext_len + 1]; snprintf(new_metapath, prefix_len+fn_len+1, "%s/metadata/%s", spooldir, meta_filename); snprintf(new_metapath + prefix_len+fn_len, ext_len+1, ".txt"); - int return_code = rename(recording->u.pcap.meta_filepath, new_metapath); + int return_code = rename(recording->pcap.meta_filepath, new_metapath); if (return_code != 0) { ilog(LOG_ERROR, "Could not move metadata file \"%s\" to \"%s/metadata/\"", - recording->u.pcap.meta_filepath, spooldir); + recording->pcap.meta_filepath, spooldir); } else { ilog(LOG_INFO, "Moved metadata file \"%s\" to \"%s/metadata\"", - recording->u.pcap.meta_filepath, spooldir); + recording->pcap.meta_filepath, spooldir); } - mutex_destroy(&recording->u.pcap.recording_lock); - g_clear_pointer(&recording->u.pcap.meta_filepath, g_free); + mutex_destroy(&recording->pcap.recording_lock); + g_clear_pointer(&recording->pcap.meta_filepath, g_free); } /** @@ -592,15 +592,15 @@ static void rec_pcap_meta_finish_file(struct call *call) { static void rec_pcap_meta_discard_file(struct call *call) { struct recording *recording = call->recording; - if (recording == NULL || recording->u.pcap.meta_fp == NULL) + if (recording == NULL || recording->pcap.meta_fp == NULL) return; - fclose(recording->u.pcap.meta_fp); - recording->u.pcap.meta_fp = NULL; + fclose(recording->pcap.meta_fp); + recording->pcap.meta_fp = NULL; - unlink(recording->u.pcap.recording_path); - unlink(recording->u.pcap.meta_filepath); - g_clear_pointer(&recording->u.pcap.meta_filepath, free); + unlink(recording->pcap.recording_path); + unlink(recording->pcap.meta_filepath); + g_clear_pointer(&recording->pcap.meta_filepath, free); } /** @@ -612,17 +612,17 @@ static char *recording_setup_file(struct recording *recording) { if (!spooldir) return NULL; - if (recording->u.pcap.recording_pd || recording->u.pcap.recording_pdumper) + if (recording->pcap.recording_pd || recording->pcap.recording_pdumper) return NULL; recording_path = file_path_str(recording->meta_prefix, "/pcaps/", ".pcap"); - recording->u.pcap.recording_path = recording_path; + recording->pcap.recording_path = recording_path; - recording->u.pcap.recording_pd = pcap_open_dead(rec_pcap_format->linktype, 65535); - recording->u.pcap.recording_pdumper = pcap_dump_open(recording->u.pcap.recording_pd, recording_path); - if (recording->u.pcap.recording_pdumper == NULL) { - pcap_close(recording->u.pcap.recording_pd); - recording->u.pcap.recording_pd = NULL; + recording->pcap.recording_pd = pcap_open_dead(rec_pcap_format->linktype, 65535); + recording->pcap.recording_pdumper = pcap_dump_open(recording->pcap.recording_pd, recording_path); + if (recording->pcap.recording_pdumper == NULL) { + pcap_close(recording->pcap.recording_pd); + recording->pcap.recording_pd = NULL; ilog(LOG_INFO, "Failed to write recording file: %s", recording_path); } else { ilog(LOG_INFO, "Writing recording file: %s", recording_path); @@ -635,13 +635,13 @@ static char *recording_setup_file(struct recording *recording) { * Flushes PCAP file, closes the dumper and descriptors, and frees object memory. */ static void rec_pcap_recording_finish_file(struct recording *recording) { - if (recording->u.pcap.recording_pdumper != NULL) { - pcap_dump_flush(recording->u.pcap.recording_pdumper); - pcap_dump_close(recording->u.pcap.recording_pdumper); - g_clear_pointer(&recording->u.pcap.recording_path, free); + if (recording->pcap.recording_pdumper != NULL) { + pcap_dump_flush(recording->pcap.recording_pdumper); + pcap_dump_close(recording->pcap.recording_pdumper); + g_clear_pointer(&recording->pcap.recording_path, free); } - if (recording->u.pcap.recording_pd != NULL) { - pcap_close(recording->u.pcap.recording_pd); + if (recording->pcap.recording_pd != NULL) { + pcap_close(recording->pcap.recording_pd); } } @@ -672,7 +672,7 @@ static void rec_pcap_eth_header(unsigned char *pkt, struct packet_stream *stream * A fair amount extraneous of packet data is spoofed. */ static void stream_pcap_dump(struct media_packet *mp, const str *s) { - pcap_dumper_t *pdumper = mp->call->recording->u.pcap.recording_pdumper; + pcap_dumper_t *pdumper = mp->call->recording->pcap.recording_pdumper; if (!pdumper) return; @@ -697,10 +697,10 @@ static void dump_packet_pcap(struct media_packet *mp, const str *s) { if (mp->media->monologue->no_recording) return; struct recording *recording = mp->call->recording; - mutex_lock(&recording->u.pcap.recording_lock); + mutex_lock(&recording->pcap.recording_lock); stream_pcap_dump(mp, s); - recording->u.pcap.packet_num++; - mutex_unlock(&recording->u.pcap.recording_lock); + recording->pcap.packet_num++; + mutex_unlock(&recording->pcap.recording_lock); } static void finish_pcap(struct call *call, bool discard) { @@ -712,11 +712,11 @@ static void finish_pcap(struct call *call, bool discard) { } static void response_pcap(struct recording *recording, bencode_item_t *output) { - if (!recording->u.pcap.recording_path) + if (!recording->pcap.recording_path) return; bencode_item_t *recordings = bencode_dictionary_add_list(output, "recordings"); - bencode_list_add_string(recordings, recording->u.pcap.recording_path); + bencode_list_add_string(recordings, recording->pcap.recording_path); } @@ -751,10 +751,10 @@ void recording_finish(struct call *call, bool discard) { static int open_proc_meta_file(struct recording *recording) { int fd; - fd = open(recording->u.proc.meta_filepath, O_WRONLY | O_APPEND | O_CREAT, 0666); + fd = open(recording->proc.meta_filepath, O_WRONLY | O_APPEND | O_CREAT, 0666); if (fd == -1) { ilog(LOG_ERR, "Failed to open recording metadata file '%s' for writing: %s", - recording->u.proc.meta_filepath, strerror(errno)); + recording->proc.meta_filepath, strerror(errno)); return -1; } return fd; @@ -808,20 +808,20 @@ static int append_meta_chunk(struct recording *recording, const char *buf, unsig static void proc_init(struct call *call) { struct recording *recording = call->recording; - recording->u.proc.call_idx = UNINIT_IDX; + recording->proc.call_idx = UNINIT_IDX; if (!kernel.is_open) { ilog(LOG_WARN, "Call recording through /proc interface requested, but kernel table not open"); return; } - recording->u.proc.call_idx = kernel_add_call(recording->meta_prefix); - if (recording->u.proc.call_idx == UNINIT_IDX) { + recording->proc.call_idx = kernel_add_call(recording->meta_prefix); + if (recording->proc.call_idx == UNINIT_IDX) { ilog(LOG_ERR, "Failed to add call to kernel recording interface: %s", strerror(errno)); return; } - ilog(LOG_DEBUG, "kernel call idx is %u", recording->u.proc.call_idx); + ilog(LOG_DEBUG, "kernel call idx is %u", recording->proc.call_idx); - recording->u.proc.meta_filepath = file_path_str(recording->meta_prefix, "/", ".meta"); - unlink(recording->u.proc.meta_filepath); // start fresh XXX good idea? + recording->proc.meta_filepath = file_path_str(recording->meta_prefix, "/", ".meta"); + unlink(recording->proc.meta_filepath); // start fresh XXX good idea? append_meta_chunk_str(recording, &call->callid, "CALL-ID"); append_meta_chunk_s(recording, recording->meta_prefix, "PARENT"); @@ -847,23 +847,23 @@ static void finish_proc(struct call *call, bool discard) { struct recording *recording = call->recording; if (!kernel.is_open) return; - if (recording->u.proc.call_idx != UNINIT_IDX) { - kernel_del_call(recording->u.proc.call_idx); - recording->u.proc.call_idx = UNINIT_IDX; + if (recording->proc.call_idx != UNINIT_IDX) { + kernel_del_call(recording->proc.call_idx); + recording->proc.call_idx = UNINIT_IDX; } for (GList *l = call->streams.head; l; l = l->next) { struct packet_stream *ps = l->data; - ps->recording.u.proc.stream_idx = UNINIT_IDX; + ps->recording.proc.stream_idx = UNINIT_IDX; } - const char *unlink_fn = recording->u.proc.meta_filepath; + const char *unlink_fn = recording->proc.meta_filepath; AUTO_CLEANUP_GBUF(discard_fn); if (discard) { - discard_fn = g_strdup_printf("%s.DISCARD", recording->u.proc.meta_filepath); - int ret = rename(recording->u.proc.meta_filepath, discard_fn); + discard_fn = g_strdup_printf("%s.DISCARD", recording->proc.meta_filepath); + int ret = rename(recording->proc.meta_filepath, discard_fn); if (ret) ilog(LOG_ERR, "Failed to rename metadata file \"%s\" to \"%s\": %s", - recording->u.proc.meta_filepath, + recording->proc.meta_filepath, discard_fn, strerror(errno)); unlink_fn = discard_fn; @@ -874,11 +874,11 @@ static void finish_proc(struct call *call, bool discard) { ilog(LOG_ERR, "Failed to delete metadata file \"%s\": %s", unlink_fn, strerror(errno)); - g_clear_pointer(&recording->u.proc.meta_filepath, free); + g_clear_pointer(&recording->proc.meta_filepath, free); } static void init_stream_proc(struct packet_stream *stream) { - stream->recording.u.proc.stream_idx = UNINIT_IDX; + stream->recording.proc.stream_idx = UNINIT_IDX; } static void setup_stream_proc(struct packet_stream *stream) { @@ -893,7 +893,7 @@ static void setup_stream_proc(struct packet_stream *stream) { return; if (!kernel.is_open) return; - if (stream->recording.u.proc.stream_idx != UNINIT_IDX) + if (stream->recording.proc.stream_idx != UNINIT_IDX) return; if (ml->no_recording) return; @@ -907,12 +907,12 @@ static void setup_stream_proc(struct packet_stream *stream) { ml->unique_id, media->index, stream->component, (PS_ISSET(stream, RTCP) && !PS_ISSET(stream, RTP)) ? "RTCP" : "RTP", stream->unique_id); - stream->recording.u.proc.stream_idx = kernel_add_intercept_stream(recording->u.proc.call_idx, buf); - if (stream->recording.u.proc.stream_idx == UNINIT_IDX) { + stream->recording.proc.stream_idx = kernel_add_intercept_stream(recording->proc.call_idx, buf); + if (stream->recording.proc.stream_idx == UNINIT_IDX) { ilog(LOG_ERR, "Failed to add stream to kernel recording interface: %s", strerror(errno)); return; } - ilog(LOG_DEBUG, "kernel stream idx is %u", stream->recording.u.proc.stream_idx); + ilog(LOG_DEBUG, "kernel stream idx is %u", stream->recording.proc.stream_idx); append_meta_chunk(recording, buf, len, "STREAM %u interface", stream->unique_id); } @@ -960,7 +960,7 @@ static void setup_media_proc(struct call_media *media) { static void dump_packet_proc(struct media_packet *mp, const str *s) { struct packet_stream *stream = mp->stream; - if (stream->recording.u.proc.stream_idx == UNINIT_IDX) + if (stream->recording.proc.stream_idx == UNINIT_IDX) return; struct rtpengine_command_packet *cmd; @@ -968,8 +968,8 @@ static void dump_packet_proc(struct media_packet *mp, const str *s) { cmd = (void *) pkt; cmd->cmd = REMG_PACKET; - //remsg->u.packet.call_idx = stream->call->recording->u.proc.call_idx; // unused - cmd->packet.stream_idx = stream->recording.u.proc.stream_idx; + //remsg->packet.call_idx = stream->call->recording->proc.call_idx; // unused + cmd->packet.stream_idx = stream->recording.proc.stream_idx; unsigned int pkt_len = fake_ip_header(cmd->packet.data, mp, s); pkt_len += sizeof(*cmd); @@ -982,11 +982,11 @@ static void dump_packet_proc(struct media_packet *mp, const str *s) { static void kernel_info_proc(struct packet_stream *stream, struct rtpengine_target_info *reti) { if (!stream->call->recording) return; - if (stream->recording.u.proc.stream_idx == UNINIT_IDX) + if (stream->recording.proc.stream_idx == UNINIT_IDX) return; - ilog(LOG_DEBUG, "enabling kernel intercept with stream idx %u", stream->recording.u.proc.stream_idx); + ilog(LOG_DEBUG, "enabling kernel intercept with stream idx %u", stream->recording.proc.stream_idx); reti->do_intercept = 1; - reti->intercept_stream_idx = stream->recording.u.proc.stream_idx; + reti->intercept_stream_idx = stream->recording.proc.stream_idx; } static void meta_chunk_proc(struct recording *recording, const char *label, const str *data) { diff --git a/daemon/rtcp.c b/daemon/rtcp.c index 5663ad66e..302cf79e5 100644 --- a/daemon/rtcp.c +++ b/daemon/rtcp.c @@ -220,7 +220,7 @@ struct rtcp_chain_element { struct bye_packet *bye; struct app_packet *app; struct xr_packet *xr; - } u; + }; }; // log handlers @@ -511,7 +511,7 @@ static struct rtcp_chain_element *rtcp_new_element(struct rtcp_header *p, unsign el = g_slice_alloc(sizeof(*el)); el->type = p->pt; el->len = len; - el->u.buf = p; + el->buf = p; return el; } @@ -521,7 +521,7 @@ static int rtcp_generic(struct rtcp_chain_element *el, struct rtcp_process_ctx * } static int rtcp_Xr(struct rtcp_chain_element *el) { - if (el->len < el->u.rtcp_packet->header.count * sizeof(struct report_block)) + if (el->len < el->rtcp_packet->header.count * sizeof(struct report_block)) return -1; return 0; } @@ -541,24 +541,24 @@ static void rtcp_rr_list(const struct rtcp_packet *common, struct report_block * static int rtcp_sr(struct rtcp_chain_element *el, struct rtcp_process_ctx *log_ctx) { if (rtcp_Xr(el)) return -1; - CAH(common, &el->u.sr->rtcp); - CAH(sr, el->u.sr); - rtcp_rr_list(&el->u.sr->rtcp, el->u.sr->reports, log_ctx); + CAH(common, &el->sr->rtcp); + CAH(sr, el->sr); + rtcp_rr_list(&el->sr->rtcp, el->sr->reports, log_ctx); return 0; } static int rtcp_rr(struct rtcp_chain_element *el, struct rtcp_process_ctx *log_ctx) { if (rtcp_Xr(el)) return -1; - CAH(common, &el->u.rr->rtcp); - rtcp_rr_list(&el->u.rr->rtcp, el->u.rr->reports, log_ctx); + CAH(common, &el->rr->rtcp); + rtcp_rr_list(&el->rr->rtcp, el->rr->reports, log_ctx); return 0; } static int rtcp_sdes(struct rtcp_chain_element *el, struct rtcp_process_ctx *log_ctx) { - CAH(sdes_list_start, el->u.sdes); + CAH(sdes_list_start, el->sdes); - str comp_s = STR_INIT_LEN((void *) el->u.sdes->chunks, el->len - sizeof(el->u.sdes->header)); + str comp_s = STR_INIT_LEN((void *) el->sdes->chunks, el->len - sizeof(el->sdes->header)); int i = 0; while (1) { struct sdes_chunk *sdes_chunk = (struct sdes_chunk *) comp_s.s; @@ -585,7 +585,7 @@ static int rtcp_sdes(struct rtcp_chain_element *el, struct rtcp_process_ctx *log // more chunks? set chunk header i++; - if (i >= el->u.sdes->header.count) + if (i >= el->sdes->header.count) break; } @@ -615,8 +615,8 @@ static void xr_voip_metrics(struct xr_rb_voip_metrics *rb, struct rtcp_process_c } static int rtcp_xr(struct rtcp_chain_element *el, struct rtcp_process_ctx *log_ctx) { - CAH(common, el->u.rtcp_packet); - str comp_s = STR_INIT_LEN(el->u.buf + sizeof(el->u.xr->rtcp), el->len - sizeof(el->u.xr->rtcp)); + CAH(common, el->rtcp_packet); + str comp_s = STR_INIT_LEN(el->buf + sizeof(el->xr->rtcp), el->len - sizeof(el->xr->rtcp)); while (1) { struct xr_report_block *rb = (void *) comp_s.s; if (comp_s.len < sizeof(*rb)) @@ -747,7 +747,7 @@ int rtcp_avpf2avp_filter(struct media_packet *mp, GQueue *rtcp_list) { switch (el->type) { case RTCP_PT_RTPFB: case RTCP_PT_PSFB: - start = el->u.buf; + start = el->buf; memmove(start - removed, start + el->len - removed, left); removed += el->len; break; diff --git a/daemon/sdp.c b/daemon/sdp.c index 602dde6b2..1f851b2df 100644 --- a/daemon/sdp.c +++ b/daemon/sdp.c @@ -275,7 +275,7 @@ struct sdp_attribute { /* example: a=rtpmap:8 PCMA/8000 */ int i; struct attribute_t38faxudpecdepth t38faxudpecdepth; struct attribute_t38faxratemanagement t38faxratemanagement; - } u; + }; }; /** @@ -408,7 +408,7 @@ static int parse_address(struct network_address *address) { do { EXTRACT_NETWORK_ADDRESS_NP(field); \ if (parse_address(&output->field)) { \ output->field.parsed.family = get_socket_family_enum(SF_IP4); \ - output->field.parsed.u.ipv4.s_addr = 1; \ + output->field.parsed.ipv4.s_addr = 1; \ } } while (0) #define PARSE_DECL str v_str, *value_str @@ -510,9 +510,9 @@ static void attr_insert(struct sdp_attributes *attrs, struct sdp_attribute *attr static int parse_attribute_group(struct sdp_attribute *output) { output->attr = ATTR_GROUP; - output->u.group.semantics = GROUP_OTHER; + output->group.semantics = GROUP_OTHER; if (output->value.len >= 7 && !strncmp(output->value.s, "BUNDLE ", 7)) - output->u.group.semantics = GROUP_BUNDLE; + output->group.semantics = GROUP_BUNDLE; return 0; } @@ -524,10 +524,10 @@ static int parse_attribute_ssrc(struct sdp_attribute *output) { output->attr = ATTR_SSRC; PARSE_INIT; - EXTRACT_TOKEN(u.ssrc.id_str); - EXTRACT_TOKEN(u.ssrc.attr_str); + EXTRACT_TOKEN(ssrc.id_str); + EXTRACT_TOKEN(ssrc.attr_str); - s = &output->u.ssrc; + s = &output->ssrc; s->id = strtoul(s->id_str.s, NULL, 10); if (!s->id) @@ -557,11 +557,11 @@ static int parse_attribute_crypto(struct sdp_attribute *output) { output->attr = ATTR_CRYPTO; PARSE_INIT; - EXTRACT_TOKEN(u.crypto.tag_str); - EXTRACT_TOKEN(u.crypto.crypto_suite_str); - EXTRACT_TOKEN(u.crypto.key_params_str); + EXTRACT_TOKEN(crypto.tag_str); + EXTRACT_TOKEN(crypto.crypto_suite_str); + EXTRACT_TOKEN(crypto.key_params_str); - c = &output->u.crypto; + c = &output->crypto; c->tag = strtoul(c->tag_str.s, &endp, 10); err = "invalid 'tag'"; @@ -691,14 +691,14 @@ static int parse_attribute_rtcp(struct sdp_attribute *output) { str portnum; if (str_token_sep(&portnum, value_str, ' ')) goto err; - output->u.rtcp.port_num = str_to_i(&portnum, 0); - if (output->u.rtcp.port_num <= 0 || output->u.rtcp.port_num > 0xffff) { - output->u.rtcp.port_num = 0; + output->rtcp.port_num = str_to_i(&portnum, 0); + if (output->rtcp.port_num <= 0 || output->rtcp.port_num > 0xffff) { + output->rtcp.port_num = 0; goto err; } if (value_str->len) - EXTRACT_NETWORK_ADDRESS(u.rtcp.address); + EXTRACT_NETWORK_ADDRESS(rtcp.address); return 0; @@ -714,17 +714,17 @@ static int parse_attribute_candidate(struct sdp_attribute *output, bool extended struct attribute_candidate *c; output->attr = ATTR_CANDIDATE; - c = &output->u.candidate; + c = &output->candidate; PARSE_INIT; - EXTRACT_TOKEN(u.candidate.cand_parsed.foundation); - EXTRACT_TOKEN(u.candidate.component_str); - EXTRACT_TOKEN(u.candidate.transport_str); - EXTRACT_TOKEN(u.candidate.priority_str); - EXTRACT_TOKEN(u.candidate.address_str); - EXTRACT_TOKEN(u.candidate.port_str); - EXTRACT_TOKEN(u.candidate.typ_str); - EXTRACT_TOKEN(u.candidate.type_str); + EXTRACT_TOKEN(candidate.cand_parsed.foundation); + EXTRACT_TOKEN(candidate.component_str); + EXTRACT_TOKEN(candidate.transport_str); + EXTRACT_TOKEN(candidate.priority_str); + EXTRACT_TOKEN(candidate.address_str); + EXTRACT_TOKEN(candidate.port_str); + EXTRACT_TOKEN(candidate.typ_str); + EXTRACT_TOKEN(candidate.type_str); c->cand_parsed.component_id = strtoul(c->component_str.s, &ep, 10); if (ep == c->component_str.s) @@ -754,10 +754,10 @@ static int parse_attribute_candidate(struct sdp_attribute *output, bool extended if (ice_has_related(c->cand_parsed.type)) { // XXX guaranteed to be in order even with extended syntax? - EXTRACT_TOKEN(u.candidate.raddr_str); - EXTRACT_TOKEN(u.candidate.related_address_str); - EXTRACT_TOKEN(u.candidate.rport_str); - EXTRACT_TOKEN(u.candidate.related_port_str); + EXTRACT_TOKEN(candidate.raddr_str); + EXTRACT_TOKEN(candidate.related_address_str); + EXTRACT_TOKEN(candidate.rport_str); + EXTRACT_TOKEN(candidate.related_port_str); if (str_cmp(&c->raddr_str, "raddr")) return -1; @@ -798,9 +798,9 @@ int sdp_parse_candidate(struct ice_candidate *cand, const str *s) { if (parse_attribute_candidate(&attr, true)) return -1; - if (!attr.u.candidate.parsed) + if (!attr.candidate.parsed) return 1; - *cand = attr.u.candidate.cand_parsed; + *cand = attr.candidate.cand_parsed; return 0; } @@ -814,34 +814,34 @@ static int parse_attribute_fingerprint(struct sdp_attribute *output) { output->attr = ATTR_FINGERPRINT; PARSE_INIT; - EXTRACT_TOKEN(u.fingerprint.hash_func_str); - EXTRACT_TOKEN(u.fingerprint.fingerprint_str); + EXTRACT_TOKEN(fingerprint.hash_func_str); + EXTRACT_TOKEN(fingerprint.fingerprint_str); - output->u.fingerprint.hash_func = dtls_find_hash_func(&output->u.fingerprint.hash_func_str); - if (!output->u.fingerprint.hash_func) + output->fingerprint.hash_func = dtls_find_hash_func(&output->fingerprint.hash_func_str); + if (!output->fingerprint.hash_func) return -1; - assert(sizeof(output->u.fingerprint.fingerprint) >= output->u.fingerprint.hash_func->num_bytes); + assert(sizeof(output->fingerprint.fingerprint) >= output->fingerprint.hash_func->num_bytes); - c = (unsigned char *) output->u.fingerprint.fingerprint_str.s; - for (i = 0; i < output->u.fingerprint.hash_func->num_bytes; i++) { + c = (unsigned char *) output->fingerprint.fingerprint_str.s; + for (i = 0; i < output->fingerprint.hash_func->num_bytes; i++) { if (c[0] >= '0' && c[0] <= '9') - output->u.fingerprint.fingerprint[i] = c[0] - '0'; + output->fingerprint.fingerprint[i] = c[0] - '0'; else if (c[0] >= 'a' && c[0] <= 'f') - output->u.fingerprint.fingerprint[i] = c[0] - 'a' + 10; + output->fingerprint.fingerprint[i] = c[0] - 'a' + 10; else if (c[0] >= 'A' && c[0] <= 'F') - output->u.fingerprint.fingerprint[i] = c[0] - 'A' + 10; + output->fingerprint.fingerprint[i] = c[0] - 'A' + 10; else return -1; - output->u.fingerprint.fingerprint[i] <<= 4; + output->fingerprint.fingerprint[i] <<= 4; if (c[1] >= '0' && c[1] <= '9') - output->u.fingerprint.fingerprint[i] |= c[1] - '0'; + output->fingerprint.fingerprint[i] |= c[1] - '0'; else if (c[1] >= 'a' && c[1] <= 'f') - output->u.fingerprint.fingerprint[i] |= c[1] - 'a' + 10; + output->fingerprint.fingerprint[i] |= c[1] - 'a' + 10; else if (c[1] >= 'A' && c[1] <= 'F') - output->u.fingerprint.fingerprint[i] |= c[1] - 'A' + 10; + output->fingerprint.fingerprint[i] |= c[1] - 'A' + 10; else return -1; @@ -854,7 +854,7 @@ static int parse_attribute_fingerprint(struct sdp_attribute *output) { return -1; done: - if (++i != output->u.fingerprint.hash_func->num_bytes) + if (++i != output->fingerprint.hash_func->num_bytes) return -1; return 0; @@ -864,13 +864,13 @@ static int parse_attribute_setup(struct sdp_attribute *output) { output->attr = ATTR_SETUP; if (!str_cmp(&output->value, "actpass")) - output->u.setup.value = SETUP_ACTPASS; + output->setup.value = SETUP_ACTPASS; else if (!str_cmp(&output->value, "active")) - output->u.setup.value = SETUP_ACTIVE; + output->setup.value = SETUP_ACTIVE; else if (!str_cmp(&output->value, "passive")) - output->u.setup.value = SETUP_PASSIVE; + output->setup.value = SETUP_PASSIVE; else if (!str_cmp(&output->value, "holdconn")) - output->u.setup.value = SETUP_HOLDCONN; + output->setup.value = SETUP_HOLDCONN; return 0; } @@ -880,13 +880,13 @@ static int parse_attribute_rtcp_fb(struct sdp_attribute *output) { struct attribute_rtcp_fb *a; output->attr = ATTR_RTCP_FB; - a = &output->u.rtcp_fb; + a = &output->rtcp_fb; PARSE_INIT; - EXTRACT_TOKEN(u.rtcp_fb.payload_type_str); + EXTRACT_TOKEN(rtcp_fb.payload_type_str); a->value = *value_str; - if (!str_cmp(&output->u.rtcp_fb.value, "*")) + if (!str_cmp(&output->rtcp_fb.value, "*")) a->payload_type = -1; else { a->payload_type = str_to_i(&a->payload_type_str, -1); @@ -906,10 +906,10 @@ static int parse_attribute_rtpmap(struct sdp_attribute *output) { output->attr = ATTR_RTPMAP; PARSE_INIT; - EXTRACT_TOKEN(u.rtpmap.payload_type_str); - EXTRACT_TOKEN(u.rtpmap.encoding_str); + EXTRACT_TOKEN(rtpmap.payload_type_str); + EXTRACT_TOKEN(rtpmap.encoding_str); - a = &output->u.rtpmap; + a = &output->rtpmap; pt = &a->rtp_pt; pt->encoding_with_params = a->encoding_str; @@ -952,10 +952,10 @@ static int parse_attribute_fmtp(struct sdp_attribute *output) { struct attribute_fmtp *a; output->attr = ATTR_FMTP; - a = &output->u.fmtp; + a = &output->fmtp; PARSE_INIT; - EXTRACT_TOKEN(u.fmtp.payload_type_str); + EXTRACT_TOKEN(fmtp.payload_type_str); a->format_parms_str = *value_str; a->payload_type = str_to_i(&a->payload_type_str, -1); @@ -967,7 +967,7 @@ static int parse_attribute_fmtp(struct sdp_attribute *output) { static int parse_attribute_int(struct sdp_attribute *output, int attr_id, int defval) { output->attr = attr_id; - output->u.i = str_to_i(&output->value, defval); + output->i = str_to_i(&output->value, defval); return 0; } @@ -977,16 +977,16 @@ static int parse_attribute_t38faxudpec(struct sdp_attribute *output) { switch (__csh_lookup(&output->value)) { case CSH_LOOKUP("t38UDPNoEC"): - output->u.t38faxudpec.ec = EC_NONE; + output->t38faxudpec.ec = EC_NONE; break; case CSH_LOOKUP("t38UDPRedundancy"): - output->u.t38faxudpec.ec = EC_REDUNDANCY; + output->t38faxudpec.ec = EC_REDUNDANCY; break; case CSH_LOOKUP("t38UDPFEC"): - output->u.t38faxudpec.ec = EC_FEC; + output->t38faxudpec.ec = EC_FEC; break; default: - output->u.t38faxudpec.ec = EC_UNKNOWN; + output->t38faxudpec.ec = EC_UNKNOWN; break; } @@ -999,13 +999,13 @@ static int parse_attribute_t38faxratemanagement(struct sdp_attribute *output) { switch (__csh_lookup(&output->value)) { case CSH_LOOKUP("localTFC"): - output->u.t38faxratemanagement.rm = RM_LOCALTCF; + output->t38faxratemanagement.rm = RM_LOCALTCF; break; case CSH_LOOKUP("transferredTCF"): - output->u.t38faxratemanagement.rm = RM_TRANSFERREDTCF; + output->t38faxratemanagement.rm = RM_TRANSFERREDTCF; break; default: - output->u.t38faxratemanagement.rm = RM_UNKNOWN; + output->t38faxratemanagement.rm = RM_UNKNOWN; break; } @@ -1017,10 +1017,10 @@ static int parse_attribute_t38faxudpecdepth(struct sdp_attribute *output) { struct attribute_t38faxudpecdepth *a; output->attr = ATTR_T38FAXUDPECDEPTH; - a = &output->u.t38faxudpecdepth; + a = &output->t38faxudpecdepth; PARSE_INIT; - EXTRACT_TOKEN(u.t38faxudpecdepth.minred_str); + EXTRACT_TOKEN(t38faxudpecdepth.minred_str); a->maxred_str = *value_str; a->minred = str_to_i(&a->minred_str, 0); @@ -1424,7 +1424,7 @@ static int __rtp_payload_types(struct stream_params *sp, struct sdp_media *media for (ql = q ? q->head : NULL; ql; ql = ql->next) { struct rtp_payload_type *pt; attr = ql->data; - pt = &attr->u.rtpmap.rtp_pt; + pt = &attr->rtpmap.rtp_pt; g_hash_table_insert(ht_rtpmap, &pt->payload_type, pt); } // do the same for a=fmtp @@ -1432,17 +1432,17 @@ static int __rtp_payload_types(struct stream_params *sp, struct sdp_media *media q = attr_list_get_by_id(&media->attributes, ATTR_FMTP); for (ql = q ? q->head : NULL; ql; ql = ql->next) { attr = ql->data; - g_hash_table_insert(ht_fmtp, &attr->u.fmtp.payload_type, &attr->u.fmtp.format_parms_str); + g_hash_table_insert(ht_fmtp, &attr->fmtp.payload_type, &attr->fmtp.format_parms_str); } // do the same for a=rtcp-fb ht_rtcp_fb = g_hash_table_new_full(g_direct_hash, g_direct_equal, NULL, (GDestroyNotify) g_queue_free); q = attr_list_get_by_id(&media->attributes, ATTR_RTCP_FB); for (ql = q ? q->head : NULL; ql; ql = ql->next) { attr = ql->data; - if (attr->u.rtcp_fb.payload_type == -1) + if (attr->rtcp_fb.payload_type == -1) continue; - GQueue *rq = g_hash_table_lookup_queue_new(ht_rtcp_fb, GINT_TO_POINTER(attr->u.rtcp_fb.payload_type), NULL); - g_queue_push_tail(rq, &attr->u.rtcp_fb.value); + GQueue *rq = g_hash_table_lookup_queue_new(ht_rtcp_fb, GINT_TO_POINTER(attr->rtcp_fb.payload_type), NULL); + g_queue_push_tail(rq, &attr->rtcp_fb.value); } /* then go through the format list and associate */ @@ -1526,7 +1526,7 @@ static void __sdp_ice(struct stream_params *sp, struct sdp_media *media) { for (ql = q->head; ql; ql = ql->next) { attr = ql->data; - ac = &attr->u.candidate; + ac = &attr->candidate; if (!ac->parsed) continue; cand = g_slice_alloc(sizeof(*cand)); @@ -1556,13 +1556,13 @@ static void __sdp_t38(struct stream_params *sp, struct sdp_media *media) { attr = attr_get_by_id(&media->attributes, ATTR_T38FAXVERSION); if (attr) - to->version = attr->u.i; + to->version = attr->i; attr = attr_get_by_id(&media->attributes, ATTR_T38FAXUDPEC); if (attr) { - if (attr->u.t38faxudpec.ec == EC_REDUNDANCY) + if (attr->t38faxudpec.ec == EC_REDUNDANCY) to->max_ec_entries = to->min_ec_entries = 3; // defaults - else if (attr->u.t38faxudpec.ec == EC_FEC) { + else if (attr->t38faxudpec.ec == EC_FEC) { // defaults to->max_ec_entries = to->min_ec_entries = 3; to->fec_span = 3; @@ -1574,21 +1574,21 @@ static void __sdp_t38(struct stream_params *sp, struct sdp_media *media) { attr = attr_get_by_id(&media->attributes, ATTR_T38FAXUDPECDEPTH); if (attr) { - to->min_ec_entries = attr->u.t38faxudpecdepth.minred; - to->max_ec_entries = attr->u.t38faxudpecdepth.maxred; + to->min_ec_entries = attr->t38faxudpecdepth.minred; + to->max_ec_entries = attr->t38faxudpecdepth.maxred; } attr = attr_get_by_id(&media->attributes, ATTR_T38FAXUDPFECMAXSPAN); if (attr) - to->fec_span = attr->u.i; + to->fec_span = attr->i; attr = attr_get_by_id(&media->attributes, ATTR_T38FAXMAXDATAGRAM); if (attr) - to->max_datagram = attr->u.i; + to->max_datagram = attr->i; attr = attr_get_by_id(&media->attributes, ATTR_T38FAXMAXIFP); if (attr) - to->max_ifp = attr->u.i; + to->max_ifp = attr->i; attr = attr_get_by_id(&media->attributes, ATTR_T38FAXFILLBITREMOVAL); if (attr && (!attr->value.len || str_cmp(&attr->value, "0"))) @@ -1604,7 +1604,7 @@ static void __sdp_t38(struct stream_params *sp, struct sdp_media *media) { attr = attr_get_by_id(&media->attributes, ATTR_T38FAXRATEMANAGEMENT); if (attr) - to->local_tcf = (attr->u.t38faxratemanagement.rm == RM_LOCALTCF) ? 1 : 0; + to->local_tcf = (attr->t38faxratemanagement.rm == RM_LOCALTCF) ? 1 : 0; } @@ -1759,22 +1759,22 @@ int sdp_streams(const GQueue *sessions, GQueue *streams, struct sdp_ng_flags *fl struct crypto_params_sdes *cps = g_slice_alloc0(sizeof(*cps)); g_queue_push_tail(&sp->sdes_params, cps); - cps->params.crypto_suite = attr->u.crypto.crypto_suite; - cps->params.mki_len = attr->u.crypto.mki_len; + cps->params.crypto_suite = attr->crypto.crypto_suite; + cps->params.mki_len = attr->crypto.mki_len; if (cps->params.mki_len) { cps->params.mki = malloc(cps->params.mki_len); - memcpy(cps->params.mki, attr->u.crypto.mki, cps->params.mki_len); + memcpy(cps->params.mki, attr->crypto.mki, cps->params.mki_len); } - cps->tag = attr->u.crypto.tag; - assert(sizeof(cps->params.master_key) >= attr->u.crypto.master_key.len); - assert(sizeof(cps->params.master_salt) >= attr->u.crypto.salt.len); - memcpy(cps->params.master_key, attr->u.crypto.master_key.s, - attr->u.crypto.master_key.len); - memcpy(cps->params.master_salt, attr->u.crypto.salt.s, - attr->u.crypto.salt.len); - cps->params.session_params.unencrypted_srtp = attr->u.crypto.unencrypted_srtp; - cps->params.session_params.unencrypted_srtcp = attr->u.crypto.unencrypted_srtcp; - cps->params.session_params.unauthenticated_srtp = attr->u.crypto.unauthenticated_srtp; + cps->tag = attr->crypto.tag; + assert(sizeof(cps->params.master_key) >= attr->crypto.master_key.len); + assert(sizeof(cps->params.master_salt) >= attr->crypto.salt.len); + memcpy(cps->params.master_key, attr->crypto.master_key.s, + attr->crypto.master_key.len); + memcpy(cps->params.master_salt, attr->crypto.salt.s, + attr->crypto.salt.len); + cps->params.session_params.unencrypted_srtp = attr->crypto.unencrypted_srtp; + cps->params.session_params.unencrypted_srtcp = attr->crypto.unencrypted_srtcp; + cps->params.session_params.unauthenticated_srtp = attr->crypto.unauthenticated_srtp; } /* a=sendrecv/sendonly/recvonly/inactive */ @@ -1793,19 +1793,19 @@ int sdp_streams(const GQueue *sessions, GQueue *streams, struct sdp_ng_flags *fl /* a=setup */ attr = attr_get_by_id_m_s(media, ATTR_SETUP); if (attr) { - if (attr->u.setup.value == SETUP_ACTPASS - || attr->u.setup.value == SETUP_ACTIVE) + if (attr->setup.value == SETUP_ACTPASS + || attr->setup.value == SETUP_ACTIVE) SP_SET(sp, SETUP_ACTIVE); - if (attr->u.setup.value == SETUP_ACTPASS - || attr->u.setup.value == SETUP_PASSIVE) + if (attr->setup.value == SETUP_ACTPASS + || attr->setup.value == SETUP_PASSIVE) SP_SET(sp, SETUP_PASSIVE); } /* a=fingerprint */ attr = attr_get_by_id_m_s(media, ATTR_FINGERPRINT); - if (attr && attr->u.fingerprint.hash_func) { - sp->fingerprint.hash_func = attr->u.fingerprint.hash_func; - memcpy(sp->fingerprint.digest, attr->u.fingerprint.fingerprint, + if (attr && attr->fingerprint.hash_func) { + sp->fingerprint.hash_func = attr->fingerprint.hash_func; + memcpy(sp->fingerprint.digest, attr->fingerprint.fingerprint, sp->fingerprint.hash_func->num_bytes); sp->fingerprint.digest_len = sp->fingerprint.hash_func->num_bytes; } @@ -1847,15 +1847,15 @@ int sdp_streams(const GQueue *sessions, GQueue *streams, struct sdp_ng_flags *fl SP_SET(sp, IMPLICIT_RTCP); goto next; } - if (attr->u.rtcp.port_num == sp->rtp_endpoint.port + if (attr->rtcp.port_num == sp->rtp_endpoint.port && !is_trickle_ice_address(&sp->rtp_endpoint)) { SP_SET(sp, RTCP_MUX); goto next; } errstr = "Invalid RTCP attribute"; - if (fill_endpoint(&sp->rtcp_endpoint, media, flags, &attr->u.rtcp.address, - attr->u.rtcp.port_num)) + if (fill_endpoint(&sp->rtcp_endpoint, media, flags, &attr->rtcp.address, + attr->rtcp.port_num)) goto error; next: @@ -2257,8 +2257,8 @@ static int process_session_attributes(struct sdp_chopper *chop, struct sdp_attri case ATTR_CANDIDATE: if (flags->ice_option == ICE_FORCE_RELAY) { - if ((attr->u.candidate.type_str.len == 5) && - (strncasecmp(attr->u.candidate.type_str.s, "relay", 5) == 0)) + if ((attr->candidate.type_str.len == 5) && + (strncasecmp(attr->candidate.type_str.s, "relay", 5) == 0)) goto strip; else break; @@ -2288,7 +2288,7 @@ static int process_session_attributes(struct sdp_chopper *chop, struct sdp_attri break; case ATTR_GROUP: - if (attr->u.group.semantics == GROUP_BUNDLE) + if (attr->group.semantics == GROUP_BUNDLE) goto strip; break; @@ -2358,8 +2358,8 @@ static int process_media_attributes(struct sdp_chopper *chop, struct sdp_media * case ATTR_CANDIDATE: if (flags->ice_option == ICE_FORCE_RELAY) { - if ((attr->u.candidate.type_str.len == 5) && - (strncasecmp(attr->u.candidate.type_str.s, "relay", 5) == 0)) + if ((attr->candidate.type_str.len == 5) && + (strncasecmp(attr->candidate.type_str.s, "relay", 5) == 0)) goto strip; else break; @@ -2400,7 +2400,7 @@ static int process_media_attributes(struct sdp_chopper *chop, struct sdp_media * goto strip; break; case ATTR_RTCP_FB: - if (attr->u.rtcp_fb.payload_type == -1) + if (attr->rtcp_fb.payload_type == -1) break; // leave this one alone if (media->codecs.codec_prefs.length > 0) goto strip; @@ -2465,7 +2465,7 @@ static void new_priority(struct sdp_media *media, enum ice_candidate_type type, for (l = cands->head; l; l = l->next) { a = l->data; - c = &a->u.candidate; + c = &a->candidate; if (c->cand_parsed.priority <= prio && c->cand_parsed.type == type && c->cand_parsed.component_id == 1) { diff --git a/daemon/stun.c b/daemon/stun.c index 0bd370be5..a1caa9a35 100644 --- a/daemon/stun.c +++ b/daemon/stun.c @@ -206,18 +206,18 @@ static int stun_attributes(struct stun_attrs *out, str *s, uint16_t *unknowns, s out->mapped.port = ntohs(*((uint16_t *) (&attr.s[2]))) ^ (STUN_COOKIE >> 16); if (attr.len == 8 && ntohs(*((uint16_t *) attr.s)) == 1) { out->mapped.address.family = get_socket_family_enum(SF_IP4); - out->mapped.address.u.ipv4.s_addr = + out->mapped.address.ipv4.s_addr = ntohl(*((uint32_t *) (&attr.s[4]))) ^ STUN_COOKIE; } else if (attr.len == 20 && ntohs(*((uint16_t *) attr.s)) == 1) { out->mapped.address.family = get_socket_family_enum(SF_IP6); - out->mapped.address.u.ipv6.s6_addr32[0] + out->mapped.address.ipv6.s6_addr32[0] = *((uint32_t *) (&attr.s[4])) ^ htonl(STUN_COOKIE); - out->mapped.address.u.ipv6.s6_addr32[1] + out->mapped.address.ipv6.s6_addr32[1] = *((uint32_t *) (&attr.s[8])) ^ req->transaction[0]; - out->mapped.address.u.ipv6.s6_addr32[2] + out->mapped.address.ipv6.s6_addr32[2] = *((uint32_t *) (&attr.s[12])) ^ req->transaction[1]; - out->mapped.address.u.ipv6.s6_addr32[3] + out->mapped.address.ipv6.s6_addr32[3] = *((uint32_t *) (&attr.s[16])) ^ req->transaction[2]; } break; @@ -505,15 +505,15 @@ static int stun_binding_success(struct stream_fd *sfd, struct header *req, struc xma.port = htons(sin->port ^ (STUN_COOKIE >> 16)); if (sin->address.family->af == AF_INET) { xma.family = htons(0x01); - xma.address[0] = sin->address.u.ipv4.s_addr ^ htonl(STUN_COOKIE); + xma.address[0] = sin->address.ipv4.s_addr ^ htonl(STUN_COOKIE); output_add_len(&mh, &xma, STUN_XOR_MAPPED_ADDRESS, 8); } else { xma.family = htons(0x02); - xma.address[0] = sin->address.u.ipv6.s6_addr32[0] ^ htonl(STUN_COOKIE); - xma.address[1] = sin->address.u.ipv6.s6_addr32[1] ^ req->transaction[0]; - xma.address[2] = sin->address.u.ipv6.s6_addr32[2] ^ req->transaction[1]; - xma.address[3] = sin->address.u.ipv6.s6_addr32[3] ^ req->transaction[2]; + xma.address[0] = sin->address.ipv6.s6_addr32[0] ^ htonl(STUN_COOKIE); + xma.address[1] = sin->address.ipv6.s6_addr32[1] ^ req->transaction[0]; + xma.address[2] = sin->address.ipv6.s6_addr32[2] ^ req->transaction[1]; + xma.address[3] = sin->address.ipv6.s6_addr32[3] ^ req->transaction[2]; output_add(&mh, &xma, STUN_XOR_MAPPED_ADDRESS); } diff --git a/include/call.h b/include/call.h index 22611d21a..63b7ce7ae 100644 --- a/include/call.h +++ b/include/call.h @@ -826,7 +826,7 @@ INLINE endpoint_t *packet_stream_local_addr(struct packet_stream *ps) { return &ps->last_local_endpoint; static endpoint_t dummy = { .address = { - .u.ipv4.s_addr = 0, + .ipv4.s_addr = 0, }, .port = 0, }; diff --git a/include/recording.h b/include/recording.h index aadbb1055..ba16eee1c 100644 --- a/include/recording.h +++ b/include/recording.h @@ -50,7 +50,7 @@ struct recording { struct { struct recording_pcap pcap; struct recording_proc proc; - } u; + }; char *escaped_callid; // call-id with dangerous characters escaped char *meta_prefix; // escaped call-id plus random suffix @@ -59,7 +59,7 @@ struct recording { struct recording_stream { union { struct recording_stream_proc proc; - } u; + }; }; struct recording_method { diff --git a/lib/codeclib.c b/lib/codeclib.c index fb327a593..c7d46d479 100644 --- a/lib/codeclib.c +++ b/lib/codeclib.c @@ -730,19 +730,19 @@ static const char *avc_decoder_init(decoder_t *dec, const str *extra_opts) { if (!codec) return "codec not supported"; - dec->u.avc.avpkt = av_packet_alloc(); + dec->avc.avpkt = av_packet_alloc(); - dec->u.avc.avcctx = avcodec_alloc_context3(codec); - if (!dec->u.avc.avcctx) + dec->avc.avcctx = avcodec_alloc_context3(codec); + if (!dec->avc.avcctx) return "failed to alloc codec context"; - SET_CHANNELS(dec->u.avc.avcctx, dec->in_format.channels); - DEF_CH_LAYOUT(&dec->u.avc.avcctx->CH_LAYOUT, dec->in_format.channels); - dec->u.avc.avcctx->sample_rate = dec->in_format.clockrate; + SET_CHANNELS(dec->avc.avcctx, dec->in_format.channels); + DEF_CH_LAYOUT(&dec->avc.avcctx->CH_LAYOUT, dec->in_format.channels); + dec->avc.avcctx->sample_rate = dec->in_format.clockrate; if (dec->def->set_dec_options) dec->def->set_dec_options(dec, extra_opts); - int i = avcodec_open2(dec->u.avc.avcctx, codec, NULL); + int i = avcodec_open2(dec->avc.avcctx, codec, NULL); if (i) { ilog(LOG_ERR | LOG_FLAG_LIMIT, "Error returned from libav: %s", av_error(i)); return "failed to open codec context"; @@ -888,7 +888,7 @@ int decoder_switch_dtx(decoder_t *dec, enum dtx_method dm) { int decoder_set_cn_dtx(decoder_t *dec, const str *cn_pl) { if (decoder_switch_dtx(dec, DTX_CN)) return -1; - dec->dtx.u.cn.cn_payload = cn_pl; + dec->dtx.cn.cn_payload = cn_pl; return 0; } @@ -900,12 +900,12 @@ gboolean decoder_has_dtx(decoder_t *dec) { static void avc_decoder_close(decoder_t *dec) { #if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(56, 1, 0) - avcodec_free_context(&dec->u.avc.avcctx); + avcodec_free_context(&dec->avc.avcctx); #else - avcodec_close(dec->u.avc.avcctx); - av_free(dec->u.avc.avcctx); + avcodec_close(dec->avc.avcctx); + av_free(dec->avc.avcctx); #endif - av_packet_free(&dec->u.avc.avpkt); + av_packet_free(&dec->avc.avpkt); } @@ -925,15 +925,15 @@ void decoder_close(decoder_t *dec) { static int avc_decoder_input(decoder_t *dec, const str *data, GQueue *out) { - if (!dec->u.avc.avpkt) + if (!dec->avc.avpkt) return -1; // decoder shut down const char *err; int av_ret = 0; - dec->u.avc.avpkt->data = (unsigned char *) data->s; - dec->u.avc.avpkt->size = data->len; - dec->u.avc.avpkt->pts = dec->pts; + dec->avc.avpkt->data = (unsigned char *) data->s; + dec->avc.avpkt->size = data->len; + dec->avc.avpkt->pts = dec->pts; AVFrame *frame = NULL; @@ -948,13 +948,13 @@ static int avc_decoder_input(decoder_t *dec, const str *data, GQueue *out) { goto err; #if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(57, 36, 0) - if (dec->u.avc.avpkt->size) { - av_ret = avcodec_send_packet(dec->u.avc.avcctx, dec->u.avc.avpkt); + if (dec->avc.avpkt->size) { + av_ret = avcodec_send_packet(dec->avc.avcctx, dec->avc.avpkt); cdbg("send packet ret %i", av_ret); err = "failed to send packet to avcodec"; if (av_ret == 0) { // consumed the packet - dec->u.avc.avpkt->size = 0; + dec->avc.avpkt->size = 0; keep_going = 1; } else { @@ -965,7 +965,7 @@ static int avc_decoder_input(decoder_t *dec, const str *data, GQueue *out) { } } - av_ret = avcodec_receive_frame(dec->u.avc.avcctx, frame); + av_ret = avcodec_receive_frame(dec->avc.avcctx, frame); cdbg("receive frame ret %i", av_ret); err = "failed to receive frame from avcodec"; if (av_ret == 0) { @@ -981,10 +981,10 @@ static int avc_decoder_input(decoder_t *dec, const str *data, GQueue *out) { } #else // only do this if we have any input left - if (dec->u.avc.avpkt->size == 0) + if (dec->avc.avpkt->size == 0) break; - av_ret = avcodec_decode_audio4(dec->u.avc.avcctx, frame, &got_frame, dec->u.avc.avpkt); + av_ret = avcodec_decode_audio4(dec->avc.avcctx, frame, &got_frame, dec->avc.avpkt); cdbg("decode frame ret %i, got frame %i", av_ret, got_frame); err = "failed to decode audio packet"; if (av_ret < 0) @@ -992,10 +992,10 @@ static int avc_decoder_input(decoder_t *dec, const str *data, GQueue *out) { if (av_ret > 0) { // consumed some input err = "invalid return value"; - if (av_ret > dec->u.avc.avpkt->size) + if (av_ret > dec->avc.avpkt->size) goto err; - dec->u.avc.avpkt->size -= av_ret; - dec->u.avc.avpkt->data += av_ret; + dec->avc.avpkt->size -= av_ret; + dec->avc.avpkt->data += av_ret; keep_going = 1; } if (got_frame) @@ -1010,8 +1010,8 @@ static int avc_decoder_input(decoder_t *dec, const str *data, GQueue *out) { frame->pts = frame->pkt_pts; #endif if (G_UNLIKELY(frame->pts == AV_NOPTS_VALUE)) - frame->pts = dec->u.avc.avpkt->pts; - dec->u.avc.avpkt->pts += frame->nb_samples; + frame->pts = dec->avc.avpkt->pts; + dec->avc.avpkt->pts += frame->nb_samples; g_queue_push_tail(out, frame); frame = NULL; @@ -1465,44 +1465,44 @@ encoder_t *encoder_new(void) { } static const char *avc_encoder_init(encoder_t *enc, const str *extra_opts) { - enc->u.avc.codec = enc->def->encoder; - if (!enc->u.avc.codec) + enc->avc.codec = enc->def->encoder; + if (!enc->avc.codec) return "output codec not found"; - enc->u.avc.avcctx = avcodec_alloc_context3(enc->u.avc.codec); - if (!enc->u.avc.avcctx) + enc->avc.avcctx = avcodec_alloc_context3(enc->avc.codec); + if (!enc->avc.avcctx) return "failed to alloc codec context"; enc->actual_format = enc->requested_format; enc->actual_format.format = -1; - for (const enum AVSampleFormat *sfmt = enc->u.avc.codec->sample_fmts; sfmt && *sfmt != -1; sfmt++) { + for (const enum AVSampleFormat *sfmt = enc->avc.codec->sample_fmts; sfmt && *sfmt != -1; sfmt++) { cdbg("supported sample format for output codec %s: %s", - enc->u.avc.codec->name, av_get_sample_fmt_name(*sfmt)); + enc->avc.codec->name, av_get_sample_fmt_name(*sfmt)); if (*sfmt == enc->requested_format.format) enc->actual_format.format = *sfmt; } - if (enc->actual_format.format == -1 && enc->u.avc.codec->sample_fmts) - enc->actual_format.format = enc->u.avc.codec->sample_fmts[0]; + if (enc->actual_format.format == -1 && enc->avc.codec->sample_fmts) + enc->actual_format.format = enc->avc.codec->sample_fmts[0]; cdbg("using output sample format %s for codec %s", - av_get_sample_fmt_name(enc->actual_format.format), enc->u.avc.codec->name); + av_get_sample_fmt_name(enc->actual_format.format), enc->avc.codec->name); - SET_CHANNELS(enc->u.avc.avcctx, enc->actual_format.channels); - DEF_CH_LAYOUT(&enc->u.avc.avcctx->CH_LAYOUT, enc->actual_format.channels); - enc->u.avc.avcctx->sample_rate = enc->actual_format.clockrate; - enc->u.avc.avcctx->sample_fmt = enc->actual_format.format; - enc->u.avc.avcctx->time_base = (AVRational){1,enc->actual_format.clockrate}; - enc->u.avc.avcctx->bit_rate = enc->bitrate; + SET_CHANNELS(enc->avc.avcctx, enc->actual_format.channels); + DEF_CH_LAYOUT(&enc->avc.avcctx->CH_LAYOUT, enc->actual_format.channels); + enc->avc.avcctx->sample_rate = enc->actual_format.clockrate; + enc->avc.avcctx->sample_fmt = enc->actual_format.format; + enc->avc.avcctx->time_base = (AVRational){1,enc->actual_format.clockrate}; + enc->avc.avcctx->bit_rate = enc->bitrate; enc->samples_per_frame = enc->actual_format.clockrate * enc->ptime / 1000; - if (enc->u.avc.avcctx->frame_size) - enc->samples_per_frame = enc->u.avc.avcctx->frame_size; + if (enc->avc.avcctx->frame_size) + enc->samples_per_frame = enc->avc.avcctx->frame_size; enc->samples_per_packet = enc->samples_per_frame; if (enc->def->set_enc_options) enc->def->set_enc_options(enc, extra_opts); - int i = avcodec_open2(enc->u.avc.avcctx, enc->u.avc.codec, NULL); + int i = avcodec_open2(enc->avc.avcctx, enc->avc.codec, NULL); if (i) { ilog(LOG_ERR | LOG_FLAG_LIMIT, "Error returned from libav: %s", av_error(i)); return "failed to open output context"; @@ -1602,12 +1602,12 @@ err: } static void avc_encoder_close(encoder_t *enc) { - if (enc->u.avc.avcctx) { - avcodec_close(enc->u.avc.avcctx); - avcodec_free_context(&enc->u.avc.avcctx); + if (enc->avc.avcctx) { + avcodec_close(enc->avc.avcctx); + avcodec_free_context(&enc->avc.avcctx); } - enc->u.avc.avcctx = NULL; - enc->u.avc.codec = NULL; + enc->avc.avcctx = NULL; + enc->avc.codec = NULL; } void encoder_close(encoder_t *enc) { @@ -1634,12 +1634,12 @@ static int avc_encoder_input(encoder_t *enc, AVFrame **frame) { int got_packet = 0; int av_ret = 0; - if (!enc->u.avc.avcctx) + if (!enc->avc.avcctx) return -1; #if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(57, 36, 0) if (*frame) { - av_ret = avcodec_send_frame(enc->u.avc.avcctx, *frame); + av_ret = avcodec_send_frame(enc->avc.avcctx, *frame); cdbg("send frame ret %i", av_ret); if (av_ret == 0) { // consumed @@ -1654,7 +1654,7 @@ static int avc_encoder_input(encoder_t *enc, AVFrame **frame) { } } - av_ret = avcodec_receive_packet(enc->u.avc.avcctx, enc->avpkt); + av_ret = avcodec_receive_packet(enc->avc.avcctx, enc->avpkt); cdbg("receive packet ret %i", av_ret); if (av_ret == 0) { // got some data @@ -1671,7 +1671,7 @@ static int avc_encoder_input(encoder_t *enc, AVFrame **frame) { if (!*frame) return 0; - av_ret = avcodec_encode_audio2(enc->u.avc.avcctx, enc->avpkt, *frame, &got_packet); + av_ret = avcodec_encode_audio2(enc->avc.avcctx, enc->avpkt, *frame, &got_packet); cdbg("encode frame ret %i, got packet %i", av_ret, got_packet); if (av_ret == 0) *frame = NULL; // consumed @@ -1823,7 +1823,7 @@ static int codeclib_set_av_opt_int(encoder_t *enc, const char *opt, int64_t val) ilog(LOG_DEBUG, "Setting ffmpeg '%s' option for '%s' to %" PRId64, opt, enc->def->rtpname, val); - int ret = av_opt_set_int(enc->u.avc.avcctx, opt, val, AV_OPT_SEARCH_CHILDREN); + int ret = av_opt_set_int(enc->avc.avcctx, opt, val, AV_OPT_SEARCH_CHILDREN); if (!ret) return 0; @@ -1909,8 +1909,8 @@ static const char *libopus_decoder_init(decoder_t *dec, const str *extra_opts) { } int err = 0; - dec->u.opus = opus_decoder_create(dec->in_format.clockrate, dec->in_format.channels, &err); - if (!dec->u.opus) { + dec->opus = opus_decoder_create(dec->in_format.clockrate, dec->in_format.channels, &err); + if (!dec->opus) { ilog(LOG_ERR | LOG_FLAG_LIMIT, "Error from libopus: %s", opus_strerror(err)); return "failed to alloc codec context"; } @@ -1918,7 +1918,7 @@ static const char *libopus_decoder_init(decoder_t *dec, const str *extra_opts) { return NULL; } static void libopus_decoder_close(decoder_t *dec) { - opus_decoder_destroy(dec->u.opus); + opus_decoder_destroy(dec->opus); } static int libopus_decoder_input(decoder_t *dec, const str *data, GQueue *out) { // get frame with buffer large enough for the max @@ -1931,7 +1931,7 @@ static int libopus_decoder_input(decoder_t *dec, const str *data, GQueue *out) { if (av_frame_get_buffer(frame, 0) < 0) abort(); - int ret = opus_decode(dec->u.opus, (unsigned char *) data->s, data->len, + int ret = opus_decode(dec->opus, (unsigned char *) data->s, data->len, (int16_t *) frame->extended_data[0], frame->nb_samples, 0); if (ret < 0) { ilog(LOG_ERR | LOG_FLAG_LIMIT, "Error decoding Opus packet: %s", opus_strerror(ret)); @@ -2021,9 +2021,9 @@ static const char *libopus_encoder_init(encoder_t *enc, const str *extra_opts) { codeclib_key_value_parse(extra_opts, true, libopus_set_enc_opts, &opts); int err; - enc->u.opus = opus_encoder_create(enc->requested_format.clockrate, enc->requested_format.channels, + enc->opus = opus_encoder_create(enc->requested_format.clockrate, enc->requested_format.channels, opts.application, &err); - if (!enc->u.opus) { + if (!enc->opus) { ilog(LOG_ERR, "Error from libopus: %s", opus_strerror(err)); return "failed to alloc codec context"; } @@ -2033,28 +2033,28 @@ static const char *libopus_encoder_init(encoder_t *enc, const str *extra_opts) { enc->samples_per_frame = enc->actual_format.clockrate * enc->ptime / 1000; enc->samples_per_packet = enc->samples_per_frame; - err = opus_encoder_ctl(enc->u.opus, OPUS_SET_BITRATE(enc->bitrate)); + err = opus_encoder_ctl(enc->opus, OPUS_SET_BITRATE(enc->bitrate)); if (err != OPUS_OK) ilog(LOG_WARN | LOG_FLAG_LIMIT, "Failed to set Opus bitrate to %i: %s", enc->bitrate, opus_strerror(err)); - err = opus_encoder_ctl(enc->u.opus, OPUS_SET_COMPLEXITY(opts.complexity)); + err = opus_encoder_ctl(enc->opus, OPUS_SET_COMPLEXITY(opts.complexity)); if (err != OPUS_OK) ilog(LOG_WARN | LOG_FLAG_LIMIT, "Failed to set Opus complexity to %i': %s", opts.complexity, opus_strerror(err)); - err = opus_encoder_ctl(enc->u.opus, OPUS_SET_VBR(opts.vbr)); + err = opus_encoder_ctl(enc->opus, OPUS_SET_VBR(opts.vbr)); if (err != OPUS_OK) ilog(LOG_WARN | LOG_FLAG_LIMIT, "Failed to set Opus VBR to %i': %s", opts.complexity, opus_strerror(err)); - err = opus_encoder_ctl(enc->u.opus, OPUS_SET_VBR_CONSTRAINT(opts.vbr_constraint)); + err = opus_encoder_ctl(enc->opus, OPUS_SET_VBR_CONSTRAINT(opts.vbr_constraint)); if (err != OPUS_OK) ilog(LOG_WARN | LOG_FLAG_LIMIT, "Failed to set Opus VBR constraint to %i': %s", opts.complexity, opus_strerror(err)); - err = opus_encoder_ctl(enc->u.opus, OPUS_SET_PACKET_LOSS_PERC(opts.pl)); + err = opus_encoder_ctl(enc->opus, OPUS_SET_PACKET_LOSS_PERC(opts.pl)); if (err != OPUS_OK) ilog(LOG_WARN | LOG_FLAG_LIMIT, "Failed to set Opus PL%% to %i': %s", opts.complexity, opus_strerror(err)); - err = opus_encoder_ctl(enc->u.opus, OPUS_SET_INBAND_FEC(enc->format_options.opus.fec_send >= 0)); + err = opus_encoder_ctl(enc->opus, OPUS_SET_INBAND_FEC(enc->format_options.opus.fec_send >= 0)); if (err != OPUS_OK) ilog(LOG_WARN | LOG_FLAG_LIMIT, "Failed to set Opus FEC to %i': %s", opts.complexity, opus_strerror(err)); @@ -2062,7 +2062,7 @@ static const char *libopus_encoder_init(encoder_t *enc, const str *extra_opts) { return NULL; } static void libopus_encoder_close(encoder_t *enc) { - opus_encoder_destroy(enc->u.opus); + opus_encoder_destroy(enc->opus); } #define MAX_OPUS_FRAME_SIZE 1275 /* 20 ms at 510 kbps */ #define MAX_OPUS_FRAMES_PER_PACKET 6 /* 120 ms = 6 * 20 ms */ @@ -2074,7 +2074,7 @@ static int libopus_encoder_input(encoder_t *enc, AVFrame **frame) { // max length of Opus packet: av_new_packet(enc->avpkt, MAX_OPUS_FRAME_SIZE * MAX_OPUS_FRAMES_PER_PACKET + MAX_OPUS_HEADER_SIZE); - int ret = opus_encode(enc->u.opus, (int16_t *) (*frame)->extended_data[0], (*frame)->nb_samples, + int ret = opus_encode(enc->opus, (int16_t *) (*frame)->extended_data[0], (*frame)->nb_samples, enc->avpkt->data, enc->avpkt->size); if (ret < 0) { ilog(LOG_ERR | LOG_FLAG_LIMIT, "Error encoding Opus packet: %s", opus_strerror(ret)); @@ -2326,9 +2326,9 @@ static void ilbc_set_enc_options(encoder_t *enc, const str *codec_opts) { static void ilbc_set_dec_options(decoder_t *dec, const str *codec_opts) { int mode = ilbc_mode(dec->ptime, &dec->format_options, "decoder"); if (mode == 20) - dec->u.avc.avcctx->block_align = 38; + dec->avc.avcctx->block_align = 38; else if (mode == 30) - dec->u.avc.avcctx->block_align = 50; + dec->avc.avcctx->block_align = 50; else ilog(LOG_WARN, "Unsupported iLBC mode %i", mode); } @@ -2353,11 +2353,11 @@ static int ilbc_decoder_input(decoder_t *dec, const str *data, GQueue *out) { ilog(LOG_WARNING | LOG_FLAG_LIMIT, "iLBC received %i bytes packet, does not match " "one of the block sizes", (int) data->len); - if (block_align && dec->u.avc.avcctx->block_align != block_align) { + if (block_align && dec->avc.avcctx->block_align != block_align) { ilog(LOG_INFO | LOG_FLAG_LIMIT, "iLBC decoder set to %i bytes blocks, but received packet " "of %i bytes, therefore resetting decoder and switching to %i bytes " "block mode (%i ms mode)", - (int) dec->u.avc.avcctx->block_align, (int) data->len, block_align, mode); + (int) dec->avc.avcctx->block_align, (int) data->len, block_align, mode); avc_decoder_close(dec); dec->format_options = *fmtp; avc_decoder_init(dec, NULL); @@ -2555,7 +2555,7 @@ static void amr_set_enc_options(encoder_t *enc, const str *codec_opts) { // if a mode-set was given, pick the highest supported bitrate if (enc->format_options.amr.mode_set) { - int max_bitrate = enc->u.avc.avcctx->bit_rate; + int max_bitrate = enc->avc.avcctx->bit_rate; int use_bitrate = 0; for (int i = 0; i < AMR_FT_TYPES; i++) { if (!(enc->format_options.amr.mode_set & (1 << i))) @@ -2575,7 +2575,7 @@ static void amr_set_enc_options(encoder_t *enc, const str *codec_opts) { else { ilog(LOG_DEBUG, "Using %i as initial %s bitrate based on mode-set", use_bitrate, enc->def->rtpname); - enc->u.avc.avcctx->bit_rate = use_bitrate; + enc->avc.avcctx->bit_rate = use_bitrate; } } } @@ -2639,8 +2639,8 @@ static void amr_bitrate_tracker(decoder_t *dec, unsigned int ft) { if (dec->codec_options.amr.cmr_interval <= 0) return; - if (dec->u.avc.u.amr.tracker_end.tv_sec - && timeval_cmp(&dec->u.avc.u.amr.tracker_end, &rtpe_now) >= 0) { + if (dec->avc.amr.tracker_end.tv_sec + && timeval_cmp(&dec->avc.amr.tracker_end, &rtpe_now) >= 0) { // analyse the data we gathered int next_highest = -1; int lowest_used = -1; @@ -2660,7 +2660,7 @@ static void amr_bitrate_tracker(decoder_t *dec, unsigned int ft) { next_highest = i; // did we see any frames? - if (!dec->u.avc.u.amr.bitrate_tracker[i]) + if (!dec->avc.amr.bitrate_tracker[i]) continue; next_highest = -1; @@ -2675,17 +2675,17 @@ static void amr_bitrate_tracker(decoder_t *dec, unsigned int ft) { } // and reset tracker - ZERO(dec->u.avc.u.amr.tracker_end); + ZERO(dec->avc.amr.tracker_end); } - if (!dec->u.avc.u.amr.tracker_end.tv_sec) { + if (!dec->avc.amr.tracker_end.tv_sec) { // init - ZERO(dec->u.avc.u.amr.bitrate_tracker); - dec->u.avc.u.amr.tracker_end = rtpe_now; - timeval_add_usec(&dec->u.avc.u.amr.tracker_end, dec->codec_options.amr.cmr_interval * 1000); + ZERO(dec->avc.amr.bitrate_tracker); + dec->avc.amr.tracker_end = rtpe_now; + timeval_add_usec(&dec->avc.amr.tracker_end, dec->codec_options.amr.cmr_interval * 1000); } - dec->u.avc.u.amr.bitrate_tracker[ft]++; + dec->avc.amr.bitrate_tracker[ft]++; } static int amr_decoder_input(decoder_t *dec, const str *data, GQueue *out) { const char *err = NULL; @@ -2708,17 +2708,17 @@ static int amr_decoder_input(decoder_t *dec, const str *data, GQueue *out) { unsigned int cmr_int = cmr_chr[0] >> 4; if (cmr_int != 15) { decoder_event(dec, CE_AMR_CMR_RECV, GUINT_TO_POINTER(cmr_int)); - dec->u.avc.u.amr.last_cmr = rtpe_now; + dec->avc.amr.last_cmr = rtpe_now; } else if (dec->codec_options.amr.mode_change_interval) { // no CMR, check if we're due to do our own mode change - if (!dec->u.avc.u.amr.last_cmr.tv_sec) // start tracking now - dec->u.avc.u.amr.last_cmr = rtpe_now; - else if (timeval_diff(&rtpe_now, &dec->u.avc.u.amr.last_cmr) + if (!dec->avc.amr.last_cmr.tv_sec) // start tracking now + dec->avc.amr.last_cmr = rtpe_now; + else if (timeval_diff(&rtpe_now, &dec->avc.amr.last_cmr) >= (long long) dec->codec_options.amr.mode_change_interval * 1000) { // switch up if we can decoder_event(dec, CE_AMR_CMR_RECV, GUINT_TO_POINTER(0xffff)); - dec->u.avc.u.amr.last_cmr = rtpe_now; + dec->avc.amr.last_cmr = rtpe_now; } } @@ -2843,7 +2843,7 @@ static unsigned int amr_encoder_find_next_mode(encoder_t *enc) { int br = enc->codec_options.amr.bitrates[i]; if (!br) // end of list break; - if (br == enc->u.avc.avcctx->bit_rate) { + if (br == enc->avc.avcctx->bit_rate) { mode = i; break; } @@ -2874,10 +2874,10 @@ static unsigned int amr_encoder_find_next_mode(encoder_t *enc) { } static void amr_encoder_mode_change(encoder_t *enc) { if (!memcmp(&enc->callback.amr.cmr_in_ts, - &enc->u.avc.u.amr.cmr_in_ts, sizeof(struct timeval))) + &enc->avc.amr.cmr_in_ts, sizeof(struct timeval))) return; // mode change requested: check if this is allowed right now - if (enc->format_options.amr.mode_change_period == 2 && (enc->u.avc.u.amr.pkt_seq & 1) != 0) + if (enc->format_options.amr.mode_change_period == 2 && (enc->avc.amr.pkt_seq & 1) != 0) return; unsigned int cmr = enc->callback.amr.cmr_in; if (cmr == 0xffff) @@ -2893,7 +2893,7 @@ static void amr_encoder_mode_change(encoder_t *enc) { int cmr_done = 1; if (enc->format_options.amr.mode_change_neighbor) { // handle non-neighbour mode changes - int cur_br = enc->u.avc.avcctx->bit_rate; + int cur_br = enc->avc.avcctx->bit_rate; // step up or down from the requested bitrate towards the current one int cmr_diff = (req_br > cur_br) ? -1 : 1; int neigh_br = req_br; @@ -2920,13 +2920,13 @@ static void amr_encoder_mode_change(encoder_t *enc) { cmr_done = 0; req_br = neigh_br; // set to this } - enc->u.avc.avcctx->bit_rate = req_br; + enc->avc.avcctx->bit_rate = req_br; if (cmr_done) - enc->u.avc.u.amr.cmr_in_ts = enc->callback.amr.cmr_in_ts; + enc->avc.amr.cmr_in_ts = enc->callback.amr.cmr_in_ts; } static void amr_encoder_got_packet(encoder_t *enc) { amr_encoder_mode_change(enc); - enc->u.avc.u.amr.pkt_seq++; + enc->avc.amr.pkt_seq++; } static int packetizer_amr(AVPacket *pkt, GString *buf, str *output, encoder_t *enc) { assert(pkt->size >= 1); @@ -2960,15 +2960,15 @@ static int packetizer_amr(AVPacket *pkt, GString *buf, str *output, encoder_t *e s[0] = '\xf0'; // no CMR req (4 bits) // or do we have a CMR? - if (!enc->u.avc.u.amr.cmr_out_seq) { - if (memcmp(&enc->u.avc.u.amr.cmr_out_ts, &enc->callback.amr.cmr_out_ts, + if (!enc->avc.amr.cmr_out_seq) { + if (memcmp(&enc->avc.amr.cmr_out_ts, &enc->callback.amr.cmr_out_ts, sizeof(struct timeval))) { - enc->u.avc.u.amr.cmr_out_seq += 3; // make this configurable? - enc->u.avc.u.amr.cmr_out_ts = enc->callback.amr.cmr_out_ts; + enc->avc.amr.cmr_out_seq += 3; // make this configurable? + enc->avc.amr.cmr_out_ts = enc->callback.amr.cmr_out_ts; } } - if (enc->u.avc.u.amr.cmr_out_seq) { - enc->u.avc.u.amr.cmr_out_seq--; + if (enc->avc.amr.cmr_out_seq) { + enc->avc.amr.cmr_out_seq--; unsigned int cmr = enc->callback.amr.cmr_out; if (cmr < AMR_FT_TYPES && enc->codec_options.amr.bitrates[cmr]) s[0] = cmr << 4; @@ -3018,7 +3018,7 @@ static int amr_dtx(decoder_t *dec, GQueue *out, int ptime) { static int generic_silence_dtx(decoder_t *dec, GQueue *out, int ptime) { if (dec->dec_out_format.format == -1) return -1; - if (!dec->u.avc.avpkt) + if (!dec->avc.avpkt) return -1; if (ptime <= 0) @@ -3040,8 +3040,8 @@ static int generic_silence_dtx(decoder_t *dec, GQueue *out, int ptime) { memset(frame->extended_data[0], 0, frame->linesize[0]); // advance PTS - frame->pts = dec->u.avc.avpkt->pts; - dec->u.avc.avpkt->pts += frame->nb_samples; + frame->pts = dec->avc.avpkt->pts; + dec->avc.avpkt->pts += frame->nb_samples; g_queue_push_tail(out, frame); @@ -3056,8 +3056,8 @@ static int cn_append_frame(decoder_t *dec, AVFrame *f, void *u1, void *u2) { } static int generic_cn_dtx(decoder_t *dec, GQueue *out, int ptime) { - dec->dtx.u.cn.cn_dec->ptime = ptime; - return decoder_input_data(dec->dtx.u.cn.cn_dec, dec->dtx.u.cn.cn_payload, + dec->dtx.cn.cn_dec->ptime = ptime; + return decoder_input_data(dec->dtx.cn.cn_dec, dec->dtx.cn.cn_payload, dec->rtp_ts, cn_append_frame, out, NULL); } @@ -3066,12 +3066,12 @@ static int generic_cn_dtx_init(decoder_t *dec) { format_t cn_format = dec->dest_format; cn_format.channels = dec->in_format.channels; cn_format.clockrate = dec->in_format.clockrate; - dec->dtx.u.cn.cn_dec = decoder_new_fmt(codec_def_cn, 8000, 1, dec->ptime, &cn_format); + dec->dtx.cn.cn_dec = decoder_new_fmt(codec_def_cn, 8000, 1, dec->ptime, &cn_format); return 0; } static void generic_cn_dtx_cleanup(decoder_t *dec) { - decoder_close(dec->dtx.u.cn.cn_dec); + decoder_close(dec->dtx.cn.cn_dec); } @@ -3093,8 +3093,8 @@ static void bcg729_def_init(struct codec_def_s *def) { } static const char *bcg729_decoder_init(decoder_t *dec, const str *extra_opts) { - dec->u.bcg729 = initBcg729DecoderChannel(); - if (!dec->u.bcg729) + dec->bcg729 = initBcg729DecoderChannel(); + if (!dec->bcg729) return "failed to initialize bcg729"; return NULL; } @@ -3121,7 +3121,7 @@ static int bcg729_decoder_input(decoder_t *dec, const str *data, GQueue *out) { pts += frame->nb_samples; // XXX handle lost packets and comfort noise - bcg729Decoder(dec->u.bcg729, (void *) inp_frame.s, inp_frame.len, 0, 0, 0, + bcg729Decoder(dec->bcg729, (void *) inp_frame.s, inp_frame.len, 0, 0, 0, (void *) frame->extended_data[0]); g_queue_push_tail(out, frame); @@ -3131,14 +3131,14 @@ static int bcg729_decoder_input(decoder_t *dec, const str *data, GQueue *out) { } static void bcg729_decoder_close(decoder_t *dec) { - if (dec->u.bcg729) - closeBcg729DecoderChannel(dec->u.bcg729); - dec->u.bcg729 = NULL; + if (dec->bcg729) + closeBcg729DecoderChannel(dec->bcg729); + dec->bcg729 = NULL; } static const char *bcg729_encoder_init(encoder_t *enc, const str *extra_opts) { - enc->u.bcg729 = initBcg729EncoderChannel(0); // no VAD - if (!enc->u.bcg729) + enc->bcg729 = initBcg729EncoderChannel(0); // no VAD + if (!enc->bcg729) return "failed to initialize bcg729"; enc->actual_format.format = AV_SAMPLE_FMT_S16; @@ -3162,7 +3162,7 @@ static int bcg729_encoder_input(encoder_t *enc, AVFrame **frame) { av_new_packet(enc->avpkt, 10); unsigned char len = 0; - bcg729Encoder(enc->u.bcg729, (void *) (*frame)->extended_data[0], enc->avpkt->data, &len); + bcg729Encoder(enc->bcg729, (void *) (*frame)->extended_data[0], enc->avpkt->data, &len); if (!len) { av_packet_unref(enc->avpkt); return 0; @@ -3176,9 +3176,9 @@ static int bcg729_encoder_input(encoder_t *enc, AVFrame **frame) { } static void bcg729_encoder_close(encoder_t *enc) { - if (enc->u.bcg729) - closeBcg729EncoderChannel(enc->u.bcg729); - enc->u.bcg729 = NULL; + if (enc->bcg729) + closeBcg729EncoderChannel(enc->bcg729); + enc->bcg729 = NULL; } static int packetizer_g729(AVPacket *pkt, GString *buf, str *input_output, encoder_t *enc) { @@ -3229,7 +3229,7 @@ static int packetizer_g729(AVPacket *pkt, GString *buf, str *input_output, encod static const char *dtmf_decoder_init(decoder_t *dec, const str *extra_opts) { - dec->u.dtmf.event = -1; + dec->dtmf.event = -1; return NULL; } @@ -3265,22 +3265,22 @@ static int dtmf_decoder_input(decoder_t *dec, const str *data, GQueue *out) { dtmf = (void *) data->s; // init if we need to - if (dtmf->event != dec->u.dtmf.event || dec->rtp_ts != dec->u.dtmf.start_ts) { - ZERO(dec->u.dtmf); - dec->u.dtmf.event = dtmf->event; - dec->u.dtmf.start_ts = dec->rtp_ts; + if (dtmf->event != dec->dtmf.event || dec->rtp_ts != dec->dtmf.start_ts) { + ZERO(dec->dtmf); + dec->dtmf.event = dtmf->event; + dec->dtmf.start_ts = dec->rtp_ts; ilog(LOG_DEBUG, "New DTMF event starting: %u at TS %lu", dtmf->event, dec->rtp_ts); } unsigned long duration = ntohs(dtmf->duration); - unsigned long frame_ts = dec->rtp_ts - dec->u.dtmf.start_ts + dec->u.dtmf.duration; - long num_samples = duration - dec->u.dtmf.duration; + unsigned long frame_ts = dec->rtp_ts - dec->dtmf.start_ts + dec->dtmf.duration; + long num_samples = duration - dec->dtmf.duration; ilog(LOG_DEBUG, "Generate DTMF samples for event %u, start TS %lu, TS now %lu, frame TS %lu, " "duration %lu, " "old duration %lu, num samples %li", - dtmf->event, dec->u.dtmf.start_ts, dec->rtp_ts, frame_ts, - duration, dec->u.dtmf.duration, num_samples); + dtmf->event, dec->dtmf.start_ts, dec->rtp_ts, frame_ts, + duration, dec->dtmf.duration, num_samples); if (num_samples <= 0) return 0; @@ -3292,10 +3292,10 @@ static int dtmf_decoder_input(decoder_t *dec, const str *data, GQueue *out) { AVFrame *frame = dtmf_frame_int16_t_mono(frame_ts, num_samples, dtmf->event, dtmf->volume, dec->in_format.clockrate); - frame->pts += dec->u.dtmf.start_ts; + frame->pts += dec->dtmf.start_ts; g_queue_push_tail(out, frame); - dec->u.dtmf.duration = duration; + dec->dtmf.duration = duration; return 0; } @@ -3321,7 +3321,7 @@ static int cn_decoder_input(decoder_t *dec, const str *data, GQueue *out) { if (ptime <= 0) ptime = 20; // ? int samples = dec->in_format.clockrate * ptime / 1000; - dec->u.avc.avcctx->frame_size = samples; + dec->avc.avcctx->frame_size = samples; int ret = avc_decoder_input(dec, data, out); if (ret) return ret; @@ -3751,7 +3751,7 @@ static void evs_select_encoder_format(encoder_t *enc, format_t *req_format, cons static const char *evs_decoder_init(decoder_t *dec, const str *extra_opts) { - dec->u.evs = g_slice_alloc0(evs_decoder_size); + dec->evs = g_slice_alloc0(evs_decoder_size); if (dec->in_format.clockrate != 48000) ilog(LOG_WARN, "EVS: invalid decoder clock rate (%i) requested", fraction_div(dec->in_format.clockrate, &dec->clockrate_fact)); @@ -3759,13 +3759,13 @@ static const char *evs_decoder_init(decoder_t *dec, const str *extra_opts) { ilog(LOG_WARN, "EVS: %i-channel EVS is not supported", dec->in_format.channels); dec->in_format.clockrate = 48000; - evs_set_decoder_Fs(dec->u.evs, dec->in_format.clockrate); - evs_init_decoder(dec->u.evs); + evs_set_decoder_Fs(dec->evs, dec->in_format.clockrate); + evs_init_decoder(dec->evs); return NULL; } static void evs_decoder_close(decoder_t *dec) { - evs_destroy_decoder(dec->u.evs); - g_slice_free1(evs_decoder_size, dec->u.evs); + evs_destroy_decoder(dec->evs); + g_slice_free1(evs_decoder_size, dec->evs); } @@ -3999,8 +3999,8 @@ static int evs_match_bitrate(int orig_br, unsigned int amr) { static const char *evs_encoder_init(encoder_t *enc, const str *extra_opts) { - enc->u.evs.ctx = g_slice_alloc0(evs_encoder_size); - enc->u.evs.ind_list = g_slice_alloc(evs_encoder_ind_list_size); + enc->evs.ctx = g_slice_alloc0(evs_encoder_size); + enc->evs.ind_list = g_slice_alloc(evs_encoder_ind_list_size); if (enc->requested_format.channels != 1) ilog(LOG_WARN, "EVS: %i-channel EVS is not supported", enc->requested_format.channels); @@ -4036,7 +4036,7 @@ static const char *evs_encoder_init(encoder_t *enc, const str *extra_opts) { ilog(LOG_WARN, "EVS: invalid encoder clock rate (%i) requested", fraction_div(enc->requested_format.clockrate, &enc->clockrate_fact)); } - evs_set_encoder_opts(enc->u.evs.ctx, enc->actual_format.clockrate, enc->u.evs.ind_list); + evs_set_encoder_opts(enc->evs.ctx, enc->actual_format.clockrate, enc->evs.ind_list); // limit bitrate to given range if (!o->amr_io) { @@ -4109,16 +4109,16 @@ static const char *evs_encoder_init(encoder_t *enc, const str *extra_opts) { } } - evs_set_encoder_brate(enc->u.evs.ctx, enc->bitrate, enc->codec_options.evs.max_bw, + evs_set_encoder_brate(enc->evs.ctx, enc->bitrate, enc->codec_options.evs.max_bw, evs_bitrate_mode(enc->bitrate), o->amr_io); - evs_init_encoder(enc->u.evs.ctx); + evs_init_encoder(enc->evs.ctx); return NULL; } static void evs_encoder_close(encoder_t *enc) { - evs_destroy_encoder(enc->u.evs.ctx); - g_slice_free1(evs_encoder_size, enc->u.evs.ctx); - g_slice_free1(evs_encoder_ind_list_size, enc->u.evs.ind_list); + evs_destroy_encoder(enc->evs.ctx); + g_slice_free1(evs_encoder_size, enc->evs.ctx); + g_slice_free1(evs_encoder_ind_list_size, enc->evs.ind_list); } @@ -4128,10 +4128,10 @@ static void evs_handle_cmr(encoder_t *enc) { if ((enc->callback.evs.cmr_in & 0x80) == 0) return; if (!memcmp(&enc->callback.evs.cmr_in_ts, - &enc->u.evs.cmr_in_ts, sizeof(struct timeval))) + &enc->evs.cmr_in_ts, sizeof(struct timeval))) return; - enc->u.evs.cmr_in_ts = enc->callback.evs.cmr_in_ts; // XXX should use a queue or something instead + enc->evs.cmr_in_ts = enc->callback.evs.cmr_in_ts; // XXX should use a queue or something instead __auto_type f = &enc->format_options.evs; __auto_type o = &enc->codec_options.evs; @@ -4167,7 +4167,7 @@ static void evs_handle_cmr(encoder_t *enc) { goto err; enc->bitrate = bitrate; - evs_set_encoder_brate(enc->u.evs.ctx, bitrate, o->max_bw, + evs_set_encoder_brate(enc->evs.ctx, bitrate, o->max_bw, evs_bitrate_mode(bitrate), f->amr_io); return; @@ -4194,9 +4194,9 @@ static int evs_encoder_input(encoder_t *enc, AVFrame **frame) { evs_handle_cmr(enc); if (!enc->format_options.evs.amr_io) - evs_enc_in(enc->u.evs.ctx, (void *) (*frame)->extended_data[0], (*frame)->nb_samples); + evs_enc_in(enc->evs.ctx, (void *) (*frame)->extended_data[0], (*frame)->nb_samples); else - evs_amr_enc_in(enc->u.evs.ctx, (void *) (*frame)->extended_data[0], (*frame)->nb_samples); + evs_amr_enc_in(enc->evs.ctx, (void *) (*frame)->extended_data[0], (*frame)->nb_samples); // max output: 320 bytes, plus some overhead av_new_packet(enc->avpkt, 340); @@ -4247,7 +4247,7 @@ static int evs_encoder_input(encoder_t *enc, AVFrame **frame) { } uint16_t bits = 0; - evs_enc_out(enc->u.evs.ctx, out, &bits); + evs_enc_out(enc->evs.ctx, out, &bits); uint16_t bytes = (bits + 7) / 8; int32_t mode = evs_mode_from_bytes(bytes); if (mode < 0) { @@ -4256,7 +4256,7 @@ static int evs_encoder_input(encoder_t *enc, AVFrame **frame) { av_packet_unref(enc->avpkt); return -1; } - evs_reset_enc_ind(enc->u.evs.ctx); + evs_reset_enc_ind(enc->evs.ctx); if (toc) { *toc = (mode & 0xff); @@ -4400,23 +4400,23 @@ static int evs_decoder_input(decoder_t *dec, const str *data, GQueue *out) { if (av_frame_get_buffer(frame, 0) < 0) abort(); - evs_dec_in(dec->u.evs, frame_data.s, bits, is_amr, mode, q_bit, 0, 0); + evs_dec_in(dec->evs, frame_data.s, bits, is_amr, mode, q_bit, 0, 0); // check for floating point implementation if (evs_syn_output) { // temp float buffer float tmp[n_samples * 3]; if (!is_amr) - evs_dec_out(dec->u.evs, tmp, 0); + evs_dec_out(dec->evs, tmp, 0); else - evs_amr_dec_out(dec->u.evs, tmp); + evs_amr_dec_out(dec->evs, tmp); float2int16_array(tmp, n_samples, (void *) frame->extended_data[0]); } else { if (!is_amr) - evs_dec_out(dec->u.evs, frame->extended_data[0], 0); + evs_dec_out(dec->evs, frame->extended_data[0], 0); else - evs_amr_dec_out(dec->u.evs, frame->extended_data[0]); + evs_amr_dec_out(dec->evs, frame->extended_data[0]); } pts += n_samples; diff --git a/lib/codeclib.h b/lib/codeclib.h index 2136295b7..a3be3fb67 100644 --- a/lib/codeclib.h +++ b/lib/codeclib.h @@ -251,7 +251,7 @@ struct dtx_method_s { decoder_t *cn_dec; const str *cn_payload; } cn; - } u; + }; }; struct decoder_s { @@ -278,7 +278,7 @@ struct decoder_s { struct timeval tracker_end; struct timeval last_cmr; } amr; - } u; + }; } avc; #ifdef HAVE_BCG729 bcg729DecoderChannelContextStruct *bcg729; @@ -290,7 +290,7 @@ struct decoder_s { } dtmf; void *evs; OpusDecoder *opus; - } u; + }; unsigned long rtp_ts; uint64_t pts; @@ -323,7 +323,7 @@ struct encoder_s { unsigned int cmr_out_seq; uint64_t pkt_seq; } amr; - } u; + }; } avc; #ifdef HAVE_BCG729 bcg729EncoderChannelContextStruct *bcg729; @@ -334,7 +334,7 @@ struct encoder_s { struct timeval cmr_in_ts; } evs; OpusEncoder *opus; - } u; + }; AVPacket *avpkt; AVAudioFifo *fifo; int64_t fifo_pts; // pts of first data in fifo diff --git a/lib/socket.c b/lib/socket.c index b486f4cf2..4f0d17401 100644 --- a/lib/socket.c +++ b/lib/socket.c @@ -145,13 +145,13 @@ socktype_t *socktype_udp; static int __ip4_addr_parse(sockaddr_t *dst, const char *src) { - if (inet_pton(AF_INET, src, &dst->u.ipv4) == 1) + if (inet_pton(AF_INET, src, &dst->ipv4) == 1) return 0; return -1; } static int __ip6_addr_parse(sockaddr_t *dst, const char *src) { if (src[0] != '[') { - if (inet_pton(AF_INET6, src, &dst->u.ipv6) == 1) + if (inet_pton(AF_INET6, src, &dst->ipv6) == 1) return 0; return -1; } @@ -166,50 +166,50 @@ static int __ip6_addr_parse(sockaddr_t *dst, const char *src) { memcpy(buf, src+1, len); buf[len] = '\0'; - if (inet_pton(AF_INET6, buf, &dst->u.ipv6) == 1) + if (inet_pton(AF_INET6, buf, &dst->ipv6) == 1) return 0; return -1; } static int __ip4_addr_print(const sockaddr_t *a, char *buf, size_t len) { buf[0] = '\0'; - if (!inet_ntop(AF_INET, &a->u.ipv4, buf, len)) + if (!inet_ntop(AF_INET, &a->ipv4, buf, len)) return -1; return 0; } static int __ip6_addr_print(const sockaddr_t *a, char *buf, size_t len) { buf[0] = '\0'; - if (!inet_ntop(AF_INET6, &a->u.ipv6, buf, len)) + if (!inet_ntop(AF_INET6, &a->ipv6, buf, len)) return -1; return 0; } static int __ip6_addr_print_p(const sockaddr_t *a, char *buf, size_t len) { buf[0] = '\0'; - if (!inet_ntop(AF_INET6, &a->u.ipv6, buf+1, len-2)) + if (!inet_ntop(AF_INET6, &a->ipv6, buf+1, len-2)) return -1; buf[0] = '['; strcpy(buf + strlen(buf), "]"); return 0; } static unsigned int __ip4_hash(const sockaddr_t *a) { - return a->u.ipv4.s_addr; + return a->ipv4.s_addr; } static unsigned int __ip6_hash(const sockaddr_t *a) { - return in6_addr_hash(&a->u.ipv6); + return in6_addr_hash(&a->ipv6); } static int __ip4_eq(const sockaddr_t *a, const sockaddr_t *b) { - return !memcmp(&a->u.ipv4, &b->u.ipv4, sizeof(a->u.ipv4)); + return !memcmp(&a->ipv4, &b->ipv4, sizeof(a->ipv4)); } static int __ip6_eq(const sockaddr_t *a, const sockaddr_t *b) { - return !memcmp(&a->u.ipv6, &b->u.ipv6, sizeof(a->u.ipv6)); + return !memcmp(&a->ipv6, &b->ipv6, sizeof(a->ipv6)); } static int __ip4_is_specified(const sockaddr_t *a) { - return a->u.ipv4.s_addr != 0; + return a->ipv4.s_addr != 0; } static int __ip6_is_specified(const sockaddr_t *a) { - return a->u.ipv6.s6_addr32[0] != 0 - || a->u.ipv6.s6_addr32[1] != 0 - || a->u.ipv6.s6_addr32[2] != 0 - || a->u.ipv6.s6_addr32[3] != 0; + return a->ipv6.s6_addr32[0] != 0 + || a->ipv6.s6_addr32[1] != 0 + || a->ipv6.s6_addr32[2] != 0 + || a->ipv6.s6_addr32[3] != 0; } static int __ip4_sockaddr2endpoint(endpoint_t *ep, const void *p) { const struct sockaddr_in *sin = p; @@ -217,7 +217,7 @@ static int __ip4_sockaddr2endpoint(endpoint_t *ep, const void *p) { return -1; ZERO(*ep); ep->address.family = &__socket_families[SF_IP4]; - ep->address.u.ipv4 = sin->sin_addr; + ep->address.ipv4 = sin->sin_addr; ep->port = ntohs(sin->sin_port); return 0; } @@ -227,7 +227,7 @@ static int __ip6_sockaddr2endpoint(endpoint_t *ep, const void *p) { return -1; ZERO(*ep); ep->address.family = &__socket_families[SF_IP6]; - ep->address.u.ipv6 = sin->sin6_addr; + ep->address.ipv6 = sin->sin6_addr; ep->port = ntohs(sin->sin6_port); return 0; } @@ -251,7 +251,7 @@ static int __ip4_addrport2sockaddr(void *p, const sockaddr_t *sa, unsigned int p sin->sin_family = AF_INET; sin->sin_port = htons(port); if (sa) - sin->sin_addr = sa->u.ipv4; + sin->sin_addr = sa->ipv4; return 0; } static int __ip6_addrport2sockaddr(void *p, const sockaddr_t *sa, unsigned int port) { @@ -260,7 +260,7 @@ static int __ip6_addrport2sockaddr(void *p, const sockaddr_t *sa, unsigned int p sin->sin6_family = AF_INET6; sin->sin6_port = htons(port); if (sa) - sin->sin6_addr = sa->u.ipv6; + sin->sin6_addr = sa->ipv6; return 0; } static int __ip_bind(socket_t *s, unsigned int port, const sockaddr_t *a) { @@ -373,7 +373,7 @@ INLINE bool __ip4_pktinfo_parse(struct cmsghdr *cm, sockaddr_t *to) { if (cm->cmsg_level != IPPROTO_IP || cm->cmsg_type != IP_PKTINFO) return false; struct in_pktinfo *pi = (void *) CMSG_DATA(cm); - to->u.ipv4 = pi->ipi_addr; + to->ipv4 = pi->ipi_addr; to->family = __get_socket_family_enum(SF_IP4); return true; } @@ -381,7 +381,7 @@ INLINE bool __ip6_pktinfo_parse(struct cmsghdr *cm, sockaddr_t *to) { if (cm->cmsg_level != IPPROTO_IPV6 || cm->cmsg_type != IPV6_PKTINFO) return false; struct in6_pktinfo *pi = (void *) CMSG_DATA(cm); - to->u.ipv6 = pi->ipi6_addr; + to->ipv6 = pi->ipi6_addr; to->family = __get_socket_family_enum(SF_IP6); return true; } @@ -448,7 +448,7 @@ static void __ip4_cmsg_pktinfo(struct cmsghdr *cm, const sockaddr_t *addr) { cm->cmsg_type = IP_PKTINFO; struct in_pktinfo *pi = (void *) CMSG_DATA(cm); ZERO(*pi); - pi->ipi_spec_dst = addr->u.ipv4; + pi->ipi_spec_dst = addr->ipv4; cm->cmsg_len = CMSG_LEN(sizeof(*pi)); } static int __ip6_pktinfo(socket_t *s) { @@ -462,19 +462,19 @@ static void __ip6_cmsg_pktinfo(struct cmsghdr *cm, const sockaddr_t *addr) { cm->cmsg_type = IPV6_PKTINFO; struct in6_pktinfo *pi = (void *) CMSG_DATA(cm); ZERO(*pi); - pi->ipi6_addr = addr->u.ipv6; + pi->ipi6_addr = addr->ipv6; cm->cmsg_len = CMSG_LEN(sizeof(*pi)); } static void __ip4_endpoint2kernel(struct re_address *ra, const endpoint_t *ep) { ZERO(*ra); ra->family = AF_INET; - ra->u.ipv4 = ep->address.u.ipv4.s_addr; + ra->u.ipv4 = ep->address.ipv4.s_addr; ra->port = ep->port; } static void __ip6_endpoint2kernel(struct re_address *ra, const endpoint_t *ep) { ZERO(*ra); ra->family = AF_INET6; - memcpy(ra->u.ipv6, &ep->address.u.ipv6, sizeof(ra->u.ipv6)); + memcpy(ra->u.ipv6, &ep->address.ipv6, sizeof(ra->u.ipv6)); ra->port = ep->port; } void kernel2endpoint(endpoint_t *ep, const struct re_address *ra) { @@ -489,10 +489,10 @@ void kernel2endpoint(endpoint_t *ep, const struct re_address *ra) { ep->address.family->kernel2endpoint(ep, ra); } static void __ip4_kernel2endpoint(endpoint_t *ep, const struct re_address *ra) { - ep->address.u.ipv4.s_addr = ra->u.ipv4; + ep->address.ipv4.s_addr = ra->u.ipv4; } static void __ip6_kernel2endpoint(endpoint_t *ep, const struct re_address *ra) { - memcpy(&ep->address.u.ipv6, ra->u.ipv6, sizeof(ep->address.u.ipv6)); + memcpy(&ep->address.ipv6, ra->u.ipv6, sizeof(ep->address.ipv6)); } static unsigned int __udp_packet_header(unsigned char *out, unsigned int src, unsigned int dst, unsigned int payload_len) @@ -519,8 +519,8 @@ static unsigned int __ip4_packet_header(unsigned char *out, const endpoint_t *sr iph->tot_len = htons(sizeof(*iph) + udp_len + payload_len); iph->ttl = 64; iph->protocol = 17; // UDP - iph->saddr = src->address.u.ipv4.s_addr; - iph->daddr = dst->address.u.ipv4.s_addr; + iph->saddr = src->address.ipv4.s_addr; + iph->daddr = dst->address.ipv4.s_addr; return sizeof(*iph) + udp_len; } @@ -538,8 +538,8 @@ static unsigned int __ip6_packet_header(unsigned char *out, const endpoint_t *sr iph->ip6_plen = htons(udp_len + payload_len); iph->ip6_nxt = 17; // UDP iph->ip6_hlim = 64; - iph->ip6_src = src->address.u.ipv6; - iph->ip6_dst = dst->address.u.ipv6; + iph->ip6_src = src->address.ipv6; + iph->ip6_dst = dst->address.ipv6; return sizeof(*iph) + udp_len; } @@ -659,12 +659,12 @@ int endpoint_parse_any(endpoint_t *d, const char *s) { static int socket_addrinfo_convert(sockaddr_t *a, struct addrinfo *res) { if (res->ai_family == AF_INET) { // IPv4 struct sockaddr_in *ipv4 = (struct sockaddr_in *) res->ai_addr; - a->u.ipv4 = ipv4->sin_addr; + a->ipv4 = ipv4->sin_addr; a->family = &__socket_families[SF_IP4]; } else if (res->ai_family == AF_INET6) { struct sockaddr_in6 *ipv6 = (struct sockaddr_in6 *) res->ai_addr; - a->u.ipv6 = ipv6->sin6_addr; + a->ipv6 = ipv6->sin6_addr; a->family = &__socket_families[SF_IP6]; } else diff --git a/lib/socket.h b/lib/socket.h index ded7a8391..3c0581aea 100644 --- a/lib/socket.h +++ b/lib/socket.h @@ -92,7 +92,7 @@ struct socket_address { union { struct in_addr ipv4; struct in6_addr ipv6; - } u; + }; }; struct endpoint { sockaddr_t address; @@ -292,7 +292,7 @@ INLINE int ipv46_any_convert(endpoint_t *ep) { if (!is_addr_unspecified(&ep->address)) return 0; ep->address.family = __get_socket_family_enum(SF_IP6); - ZERO(ep->address.u.ipv6); + ZERO(ep->address.ipv6); return 1; } // needs a writeable str diff --git a/recording-daemon/output.c b/recording-daemon/output.c index bdff466eb..1478381d8 100644 --- a/recording-daemon/output.c +++ b/recording-daemon/output.c @@ -261,10 +261,10 @@ int output_config(output_t *output, const format_t *requested_format, format_t * output->requested_format.format = output->actual_format.format; err = "failed to alloc output stream"; - output->avst = avformat_new_stream(output->fmtctx, output->encoder->u.avc.codec); + output->avst = avformat_new_stream(output->fmtctx, output->encoder->avc.codec); if (!output->avst) goto err; - output->avst->time_base = output->encoder->u.avc.avcctx->time_base; + output->avst->time_base = output->encoder->avc.avcctx->time_base; #if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(57, 0, 0) // move the avcctx to avst as we already have an initialized avcctx @@ -272,11 +272,11 @@ int output_config(output_t *output, const format_t *requested_format, format_t * avcodec_close(output->avst->codec); avcodec_free_context(&output->avst->codec); } - output->avst->codec = output->encoder->u.avc.avcctx; + output->avst->codec = output->encoder->avc.avcctx; #endif #if LIBAVFORMAT_VERSION_INT >= AV_VERSION_INT(57, 26, 0) // exact version? present in 57.56 - avcodec_parameters_from_context(output->avst->codecpar, output->encoder->u.avc.avcctx); + avcodec_parameters_from_context(output->avst->codecpar, output->encoder->avc.avcctx); #endif char *full_fn = NULL; @@ -351,7 +351,7 @@ static bool output_shutdown(output_t *output) { #if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(57, 0, 0) // avoid double free - avcctx already freed - output->encoder->u.avc.avcctx = NULL; + output->encoder->avc.avcctx = NULL; #endif encoder_close(output->encoder); diff --git a/t/Makefile b/t/Makefile index 4e19617ba..e03ba4eab 100644 --- a/t/Makefile +++ b/t/Makefile @@ -237,7 +237,7 @@ test-kernel-module: test-kernel-module.o $(COMMONOBJS) kernel.o test-const_str_hash.strhash: test-const_str_hash.strhash.o $(COMMONOBJS) -PRELOAD_CFLAGS += -D_GNU_SOURCE -std=c99 +PRELOAD_CFLAGS += -D_GNU_SOURCE -std=c11 PRELOAD_LIBS += -ldl tests-preload.so: tests-preload.c