aft: Avoid invalid read.
[paraslash.git] / opus_afh.c
index 880e903..dca6cfb 100644 (file)
@@ -1,3 +1,7 @@
+/* Copyright (C) 2012 Andre Noll <maan@tuebingen.mpg.de>, see file COPYING. */
+
+/** \file opus_afh.c Audio format handler for ogg/opus files. */
+
 #include <ogg/ogg.h>
 #include <regex.h>
 
 #include "string.h"
 #include "opus_common.h"
 #include "ogg_afh_common.h"
-/**
- * The init function of the ogg/opus audio format handler.
+
+static const char * const opus_suffixes[] = {"opus", NULL};
+
+#define OPUS_COMMENT_HEADER "OpusTags"
+
+static bool copy_if_tag_type(const char *tag, int taglen, const char *type,
+               char **p)
+{
+       char *q = key_value_copy(tag, taglen, type);
+       if (!q)
+               return false;
+       free(*p);
+       *p = q;
+       return true;
+}
+
+static int opus_get_comments(char *comments, int length,
+               struct taginfo *tags)
+{
+       char *p = comments, *end = comments + length;
+       int i;
+       uint32_t val, ntags;
+
+       /* min size of a opus header is 16 bytes */
+       if (length < 16)
+               return -E_OPUS_COMMENT;
+       if (memcmp(p, OPUS_COMMENT_HEADER, strlen(OPUS_COMMENT_HEADER)) != 0)
+               return -E_OPUS_COMMENT;
+       p += 8;
+       val = read_u32(p);
+       p += 4;
+       if (p + val > end)
+               return -E_OPUS_COMMENT;
+       tags->comment = safe_strdup(p, val);
+       p += val;
+       ntags = read_u32(p);
+       p += 4;
+       if (p + ntags * 4 > end)
+               return -E_OPUS_COMMENT;
+       PARA_INFO_LOG("found %u tag(s)\n", ntags);
+       for (i = 0; i < ntags; i++, p += val) {
+               char *tag;
+
+               if (p + 4 > end)
+                       return -E_OPUS_COMMENT;
+               val = read_u32(p);
+               p += 4;
+               if (p + val > end)
+                       return -E_OPUS_COMMENT;
+               if (copy_if_tag_type(p, val, "author", &tags->artist))
+                       continue;
+               if (copy_if_tag_type(p, val, "artist", &tags->artist))
+                       continue;
+               if (copy_if_tag_type(p, val, "title", &tags->title))
+                       continue;
+               if (copy_if_tag_type(p, val, "album", &tags->album))
+                       continue;
+               if (copy_if_tag_type(p, val, "year", &tags->year))
+                       continue;
+               if (copy_if_tag_type(p, val, "comment", &tags->comment))
+                       continue;
+               tag = safe_strdup(p, val);
+               PARA_NOTICE_LOG("unrecognized tag: %s\n", tag);
+               free(tag);
+       }
+       return 1;
+}
+
+/*
+ * Ogg/Opus has two mandatory header packets:
+ *
+ * 1. ID header (identifies the stream as Opus). Dedicated "BOS" ogg page.
+ * 2. Comment header (metadata). May span multiple pages.
  *
- * \param afh Pointer to the struct to initialize.
+ * See doc/draft-ietf-codec-oggopus.xml in the opus source tree for details.
+ */
+static int opus_packet_callback(ogg_packet *packet, int packet_num,
+               __a_unused int serial, struct afh_info *afhi,
+               void *private_data)
+{
+       int ret;
+       struct opus_header *oh = private_data;
+
+       if (packet_num == 0) {
+               ret = opus_parse_header((char *)packet->packet, packet->bytes, oh);
+               if (ret < 0)
+                       return ret;
+               afhi->channels = oh->channels;
+               afhi->techinfo = make_message(
+                       "header version %d, input sample rate: %" PRIu32 "Hz",
+                       oh->version, oh->input_sample_rate);
+               /*
+                * The input sample rate is irrelevant for afhi->frequency as
+                * we always decode to 48kHz.
+                */
+               afhi->frequency = 48000;
+               return 1;
+       }
+       if (packet_num == 1) {
+               ret = opus_get_comments((char *)packet->packet, packet->bytes,
+                       &afhi->tags);
+               if (ret < 0)
+                       return ret;
+               return 0; /* header complete */
+       }
+       /* never reached */
+       assert(0);
+}
+
+static int opus_get_file_info(char *map, size_t numbytes, __a_unused int fd,
+               struct afh_info *afhi)
+{
+       int ret, ms;
+       struct opus_header oh = {.version = 0};
+
+       struct oac_callback_info opus_callback_info = {
+               .packet_callback = opus_packet_callback,
+               .private_data = &oh,
+       };
+       ret = oac_get_file_info(map, numbytes, afhi, &opus_callback_info);
+       if (ret < 0)
+               return ret;
+       ret = (afhi->chunk_table[afhi->chunks_total] - afhi->chunk_table[0]) * 8; /* bits */
+       ms = tv2ms(&afhi->chunk_tv) * afhi->chunks_total;
+       afhi->bitrate = ret / ms;
+       return 1;
+}
+
+static size_t opus_make_meta_packet(struct taginfo *tags, char **result)
+{
+       size_t sz;
+       char *buf, *p;
+       size_t comment_len = strlen(tags->comment),
+               artist_len = strlen(tags->artist),
+               title_len = strlen(tags->title),
+               album_len = strlen(tags->album),
+               year_len = strlen(tags->year);
+       uint32_t comment_sz = comment_len,
+               artist_sz = artist_len + strlen("artist="),
+               title_sz = title_len + strlen("title="),
+               album_sz = album_len + strlen("album="),
+               year_sz = year_len + strlen("year=");
+       uint32_t num_tags;
+
+       sz = strlen(OPUS_COMMENT_HEADER)
+               + 4 /* comment length (always present) */
+               + comment_sz
+               + 4; /* number of tags */
+       num_tags = 0;
+       if (artist_len) {
+               num_tags++;
+               sz += 4 + artist_sz;
+       }
+       if (title_len) {
+               num_tags++;
+               sz += 4 + title_sz;
+       }
+       if (album_len) {
+               num_tags++;
+               sz += 4 + album_sz;
+       }
+       if (year_len) {
+               num_tags++;
+               sz += 4 + year_sz;
+       }
+       PARA_DEBUG_LOG("meta packet size: %zu bytes\n", sz);
+       /* terminating zero byte for the last sprintf() */
+       buf = p = para_malloc(sz + 1);
+       memcpy(p, OPUS_COMMENT_HEADER, strlen(OPUS_COMMENT_HEADER));
+       p += strlen(OPUS_COMMENT_HEADER);
+       write_u32(p, comment_sz);
+       p += 4;
+       strcpy(p, tags->comment);
+       p += comment_sz;
+       write_u32(p, num_tags);
+       p += 4;
+       if (artist_len) {
+               write_u32(p, artist_sz);
+               p += 4;
+               sprintf(p, "artist=%s", tags->artist);
+               p += artist_sz;
+       }
+       if (title_len) {
+               write_u32(p, title_sz);
+               p += 4;
+               sprintf(p, "title=%s", tags->title);
+               p += title_sz;
+       }
+       if (album_len) {
+               write_u32(p, album_sz);
+               p += 4;
+               sprintf(p, "album=%s", tags->album);
+               p += album_sz;
+       }
+       if (year_len) {
+               write_u32(p, year_sz);
+               p += 4;
+               sprintf(p, "year=%s", tags->year);
+               p += year_sz;
+       }
+       assert(p == buf + sz);
+       *result = buf;
+       return sz;
+}
+
+static int opus_rewrite_tags(const char *map, size_t mapsize,
+               struct taginfo *tags, int output_fd,
+               __a_unused const char *filename)
+{
+       char *meta_packet;
+       size_t meta_sz;
+       int ret;
+
+       meta_sz = opus_make_meta_packet(tags, &meta_packet);
+       ret = oac_rewrite_tags(map, mapsize, output_fd, meta_packet, meta_sz);
+       free(meta_packet);
+       return ret;
+}
+
+/*
+ * See doc/draft-ietf-codec-oggopus.xml in the opus source tree for details
+ * about the format of the comment header.
  */
-void opus_afh_init(struct audio_format_handler *afh)
+static int opus_get_header_callback(ogg_packet *packet, int packet_num,
+               int serial, __a_unused struct afh_info *afhi, void *private_data)
+{
+       struct oac_custom_header *h = private_data;
+       int ret;
+       static unsigned char dummy_tags[] = { /* a minimal comment header */
+               'O', 'p', 'u', 's', 'T', 'a', 'g', 's',
+               0x06, 0x00, 0x00, 0x00, /* vendor string length */
+               'd', 'u', 'm', 'm', 'y', '\0', /* vendor string */
+               0x00, 0x00, 0x00, 0x00, /* user comment list length */
+       };
+       ogg_packet replacement;
+
+       if (packet_num == 0) {
+               oac_custom_header_init(serial, h);
+               ret = oac_custom_header_append(packet, h);
+               if (ret < 0)
+                       return ret;
+               oac_custom_header_flush(h);
+               return 1;
+       }
+       assert(packet_num == 1);
+       PARA_INFO_LOG("replacing metadata packet\n");
+       replacement = *packet;
+       replacement.packet = dummy_tags;
+       replacement.bytes = sizeof(dummy_tags);
+       ret = oac_custom_header_append(&replacement, h);
+       if (ret < 0)
+               return ret;
+       oac_custom_header_flush(h);
+       return 0;
+}
+
+static void opus_get_header(void *map, size_t mapsize, char **buf,
+               size_t *len)
 {
+       int ret;
+       struct oac_custom_header *h = oac_custom_header_new();
+       struct oac_callback_info cb = {
+               .packet_callback = opus_get_header_callback,
+               .private_data = h,
+       };
 
+       ret = oac_get_file_info(map, mapsize, NULL, &cb);
+       *len = oac_custom_header_get(buf, h);
+       if (ret < 0) {
+               PARA_ERROR_LOG("could not create custom header: %s\n",
+                       para_strerror(-ret));
+               free(*buf);
+               *buf = NULL;
+               *len = 0;
+       } else
+               PARA_INFO_LOG("created %zu byte ogg/opus header\n", *len);
 }
+
+/**
+ * The audio format handler for ogg/opus.
+ *
+ * The opus codec was standardized by the Internet Engineering Task Force and
+ * is described in RFC 6716 (2012). The audio format handler depends on the ogg
+ * and the opus libraries.
+ */
+const struct audio_format_handler opus_afh = {
+       .get_file_info = opus_get_file_info,
+       .get_header = opus_get_header,
+       .suffixes = opus_suffixes,
+       .rewrite_tags = opus_rewrite_tags,
+};