opus_afh.c

   1 /* Copyright (C) 2012 Andre Noll <maan@tuebingen.mpg.de>, see file COPYING. */
   2
   3 /** \file opus_afh.c Audio format handler for ogg/opus files. */
   4
   5 #include <ogg/ogg.h>
   6 #include <regex.h>
   7
   8 #include "para.h"
   9 #include "afh.h"
  10 #include "error.h"
  11 #include "portable_io.h"
  12 #include "string.h"
  13 #include "opus_common.h"
  14 #include "ogg_afh_common.h"
  15
  16 static const char * const opus_suffixes[] = {"opus", NULL};
  17
  18 #define OPUS_COMMENT_HEADER "OpusTags"
  19
  20 static bool copy_if_tag_type(const char *tag, int taglen, const char *type,
  21                 char **p)
  22 {
  23         char *q = key_value_copy(tag, taglen, type);
  24         if (!q)
  25                 return false;
  26         free(*p);
  27         *p = q;
  28         return true;
  29 }
  30
  31 static int opus_get_comments(char *comments, int length,
  32                 struct taginfo *tags)
  33 {
  34         char *p = comments, *end = comments + length;
  35         int i;
  36         uint32_t val, ntags;
  37
  38         /* min size of a opus header is 16 bytes */
  39         if (length < 16)
  40                 return -E_OPUS_COMMENT;
  41         if (memcmp(p, OPUS_COMMENT_HEADER, strlen(OPUS_COMMENT_HEADER)) != 0)
  42                 return -E_OPUS_COMMENT;
  43         p += 8;
  44         val = read_u32(p);
  45         p += 4;
  46         if (p + val > end)
  47                 return -E_OPUS_COMMENT;
  48         tags->comment = safe_strdup(p, val);
  49         p += val;
  50         ntags = read_u32(p);
  51         p += 4;
  52         if (p + ntags * 4 > end)
  53                 return -E_OPUS_COMMENT;
  54         PARA_INFO_LOG("found %u tag(s)\n", ntags);
  55         for (i = 0; i < ntags; i++, p += val) {
  56                 char *tag;
  57
  58                 if (p + 4 > end)
  59                         return -E_OPUS_COMMENT;
  60                 val = read_u32(p);
  61                 p += 4;
  62                 if (p + val > end)
  63                         return -E_OPUS_COMMENT;
  64                 if (copy_if_tag_type(p, val, "author", &tags->artist))
  65                         continue;
  66                 if (copy_if_tag_type(p, val, "artist", &tags->artist))
  67                         continue;
  68                 if (copy_if_tag_type(p, val, "title", &tags->title))
  69                         continue;
  70                 if (copy_if_tag_type(p, val, "album", &tags->album))
  71                         continue;
  72                 if (copy_if_tag_type(p, val, "year", &tags->year))
  73                         continue;
  74                 if (copy_if_tag_type(p, val, "comment", &tags->comment))
  75                         continue;
  76                 tag = safe_strdup(p, val);
  77                 PARA_NOTICE_LOG("unrecognized tag: %s\n", tag);
  78                 free(tag);
  79         }
  80         return 1;
  81 }
  82
  83 /*
  84  * Ogg/Opus has two mandatory header packets:
  85  *
  86  * 1. ID header (identifies the stream as Opus). Dedicated "BOS" ogg page.
  87  * 2. Comment header (metadata). May span multiple pages.
  88  *
  89  * See doc/draft-ietf-codec-oggopus.xml in the opus source tree for details.
  90  */
  91 static int opus_packet_callback(ogg_packet *packet, int packet_num,
  92                 __a_unused int serial, struct afh_info *afhi,
  93                 void *private_data)
  94 {
  95         int ret;
  96         struct opus_header *oh = private_data;
  97
  98         if (packet_num == 0) {
  99                 ret = opus_parse_header((char *)packet->packet, packet->bytes, oh);
 100                 if (ret < 0)
 101                         return ret;
 102                 afhi->channels = oh->channels;
 103                 afhi->techinfo = make_message(
 104                         "header version %d, input sample rate: %" PRIu32 "Hz",
 105                         oh->version, oh->input_sample_rate);
 106                 /*
 107                  * The input sample rate is irrelevant for afhi->frequency as
 108                  * we always decode to 48kHz.
 109                  */
 110                 afhi->frequency = 48000;
 111                 return 1;
 112         }
 113         if (packet_num == 1) {
 114                 ret = opus_get_comments((char *)packet->packet, packet->bytes,
 115                         &afhi->tags);
 116                 if (ret < 0)
 117                         return ret;
 118                 return 0; /* header complete */
 119         }
 120         /* never reached */
 121         assert(0);
 122 }
 123
 124 static int opus_get_file_info(char *map, size_t numbytes, __a_unused int fd,
 125                 struct afh_info *afhi)
 126 {
 127         int ret, ms;
 128         struct opus_header oh = {.version = 0};
 129
 130         struct oac_callback_info opus_callback_info = {
 131                 .packet_callback = opus_packet_callback,
 132                 .private_data = &oh,
 133         };
 134         ret = oac_get_file_info(map, numbytes, afhi, &opus_callback_info);
 135         if (ret < 0)
 136                 return ret;
 137         ret = (afhi->chunk_table[afhi->chunks_total] - afhi->chunk_table[0]) * 8; /* bits */
 138         ms = tv2ms(&afhi->chunk_tv) * afhi->chunks_total;
 139         afhi->bitrate = ret / ms;
 140         return 1;
 141 }
 142
 143 static size_t opus_make_meta_packet(struct taginfo *tags, char **result)
 144 {
 145         size_t sz;
 146         char *buf, *p;
 147         size_t comment_len = strlen(tags->comment),
 148                 artist_len = strlen(tags->artist),
 149                 title_len = strlen(tags->title),
 150                 album_len = strlen(tags->album),
 151                 year_len = strlen(tags->year);
 152         uint32_t comment_sz = comment_len,
 153                 artist_sz = artist_len + strlen("artist="),
 154                 title_sz = title_len + strlen("title="),
 155                 album_sz = album_len + strlen("album="),
 156                 year_sz = year_len + strlen("year=");
 157         uint32_t num_tags;
 158
 159         sz = strlen(OPUS_COMMENT_HEADER)
 160                 + 4 /* comment length (always present) */
 161                 + comment_sz
 162                 + 4; /* number of tags */
 163         num_tags = 0;
 164         if (artist_len) {
 165                 num_tags++;
 166                 sz += 4 + artist_sz;
 167         }
 168         if (title_len) {
 169                 num_tags++;
 170                 sz += 4 + title_sz;
 171         }
 172         if (album_len) {
 173                 num_tags++;
 174                 sz += 4 + album_sz;
 175         }
 176         if (year_len) {
 177                 num_tags++;
 178                 sz += 4 + year_sz;
 179         }
 180         PARA_DEBUG_LOG("meta packet size: %zu bytes\n", sz);
 181         /* terminating zero byte for the last sprintf() */
 182         buf = p = para_malloc(sz + 1);
 183         memcpy(p, OPUS_COMMENT_HEADER, strlen(OPUS_COMMENT_HEADER));
 184         p += strlen(OPUS_COMMENT_HEADER);
 185         write_u32(p, comment_sz);
 186         p += 4;
 187         strcpy(p, tags->comment);
 188         p += comment_sz;
 189         write_u32(p, num_tags);
 190         p += 4;
 191         if (artist_len) {
 192                 write_u32(p, artist_sz);
 193                 p += 4;
 194                 sprintf(p, "artist=%s", tags->artist);
 195                 p += artist_sz;
 196         }
 197         if (title_len) {
 198                 write_u32(p, title_sz);
 199                 p += 4;
 200                 sprintf(p, "title=%s", tags->title);
 201                 p += title_sz;
 202         }
 203         if (album_len) {
 204                 write_u32(p, album_sz);
 205                 p += 4;
 206                 sprintf(p, "album=%s", tags->album);
 207                 p += album_sz;
 208         }
 209         if (year_len) {
 210                 write_u32(p, year_sz);
 211                 p += 4;
 212                 sprintf(p, "year=%s", tags->year);
 213                 p += year_sz;
 214         }
 215         assert(p == buf + sz);
 216         *result = buf;
 217         return sz;
 218 }
 219
 220 static int opus_rewrite_tags(const char *map, size_t mapsize,
 221                 struct taginfo *tags, int output_fd,
 222                 __a_unused const char *filename)
 223 {
 224         char *meta_packet;
 225         size_t meta_sz;
 226         int ret;
 227
 228         meta_sz = opus_make_meta_packet(tags, &meta_packet);
 229         ret = oac_rewrite_tags(map, mapsize, output_fd, meta_packet, meta_sz);
 230         free(meta_packet);
 231         return ret;
 232 }
 233
 234 /*
 235  * See doc/draft-ietf-codec-oggopus.xml in the opus source tree for details
 236  * about the format of the comment header.
 237  */
 238 static int opus_get_header_callback(ogg_packet *packet, int packet_num,
 239                 int serial, __a_unused struct afh_info *afhi, void *private_data)
 240 {
 241         struct oac_custom_header *h = private_data;
 242         int ret;
 243         static unsigned char dummy_tags[] = { /* a minimal comment header */
 244                 'O', 'p', 'u', 's', 'T', 'a', 'g', 's',
 245                 0x06, 0x00, 0x00, 0x00, /* vendor string length */
 246                 'd', 'u', 'm', 'm', 'y', '\0', /* vendor string */
 247                 0x00, 0x00, 0x00, 0x00, /* user comment list length */
 248         };
 249         ogg_packet replacement;
 250
 251         if (packet_num == 0) {
 252                 oac_custom_header_init(serial, h);
 253                 ret = oac_custom_header_append(packet, h);
 254                 if (ret < 0)
 255                         return ret;
 256                 oac_custom_header_flush(h);
 257                 return 1;
 258         }
 259         assert(packet_num == 1);
 260         PARA_INFO_LOG("replacing metadata packet\n");
 261         replacement = *packet;
 262         replacement.packet = dummy_tags;
 263         replacement.bytes = sizeof(dummy_tags);
 264         ret = oac_custom_header_append(&replacement, h);
 265         if (ret < 0)
 266                 return ret;
 267         oac_custom_header_flush(h);
 268         return 0;
 269 }
 270
 271 static void opus_get_header(void *map, size_t mapsize, char **buf,
 272                 size_t *len)
 273 {
 274         int ret;
 275         struct oac_custom_header *h = oac_custom_header_new();
 276         struct oac_callback_info cb = {
 277                 .packet_callback = opus_get_header_callback,
 278                 .private_data = h,
 279         };
 280
 281         ret = oac_get_file_info(map, mapsize, NULL, &cb);
 282         *len = oac_custom_header_get(buf, h);
 283         if (ret < 0) {
 284                 PARA_ERROR_LOG("could not create custom header: %s\n",
 285                         para_strerror(-ret));
 286                 free(*buf);
 287                 *buf = NULL;
 288                 *len = 0;
 289         } else
 290                 PARA_INFO_LOG("created %zu byte ogg/opus header\n", *len);
 291 }
 292
 293 /**
 294  * The init function of the ogg/opus audio format handler.
 295  *
 296  * \param afh Pointer to the struct to initialize.
 297  */
 298 void opus_afh_init(struct audio_format_handler *afh)
 299 {
 300         afh->get_file_info = opus_get_file_info,
 301         afh->get_header = opus_get_header;
 302         afh->suffixes = opus_suffixes;
 303         afh->rewrite_tags = opus_rewrite_tags;
 304 }