spx_afh.c

   1 /*
   2  * Copyright (C) 2010 Andre Noll <maan@tuebingen.mpg.de>
   3  *
   4  * Licensed under the GPL v2. For licencing details see COPYING.
   5  */
   6
   7 /* This file is based on speexdec.c, by Jean-Marc Valin, see below. */
   8
   9 /* Copyright (C) 2002-2006 Jean-Marc Valin
  10    File: speexdec.c
  11
  12    Redistribution and use in source and binary forms, with or without
  13    modification, are permitted provided that the following conditions
  14    are met:
  15
  16    - Redistributions of source code must retain the above copyright
  17    notice, this list of conditions and the following disclaimer.
  18
  19    - Redistributions in binary form must reproduce the above copyright
  20    notice, this list of conditions and the following disclaimer in the
  21    documentation and/or other materials provided with the distribution.
  22
  23    - Neither the name of the Xiph.org Foundation nor the names of its
  24    contributors may be used to endorse or promote products derived from
  25    this software without specific prior written permission.
  26
  27    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  28    ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  29    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  30    A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR
  31    CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  32    EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  33    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  34    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  35    LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  36    NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  37    SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  38 */
  39 /** \file spx_afh.c Audio format handler for ogg/speex files. */
  40
  41 #include <ogg/ogg.h>
  42 #include <regex.h>
  43 #include <speex/speex.h>
  44 #include <speex/speex_header.h>
  45 #include <speex/speex_stereo.h>
  46
  47 #include "para.h"
  48 #include "afh.h"
  49 #include "error.h"
  50 #include "portable_io.h"
  51 #include "string.h"
  52 #include "spx.h"
  53 #include "ogg_afh_common.h"
  54
  55 struct private_spx_data {
  56         struct spx_header_info shi;
  57 };
  58
  59 static bool copy_if_tag_type(const char *tag, int taglen, const char *type,
  60                 char **p)
  61 {
  62         char *q = key_value_copy(tag, taglen, type);
  63         if (!q)
  64                 return false;
  65         free(*p);
  66         *p = q;
  67         return true;
  68 }
  69
  70 static int spx_get_comments(unsigned char *comments, int length,
  71                 struct taginfo *tags)
  72 {
  73         char *c = (char *)comments;
  74         uint32_t len, nb_fields;
  75         int i;
  76         char *end;
  77
  78         if (length < 8)
  79                 return -E_SPX_COMMENT;
  80         end = c + length;
  81         len = read_u32(c);
  82         c += 4;
  83         if (c + len > end)
  84                 return -E_SPX_COMMENT;
  85         tags->comment = safe_strdup(c, len);
  86
  87         c += len;
  88         if (c + 4 > end)
  89                 return -E_SPX_COMMENT;
  90         nb_fields = read_u32(c);
  91         PARA_DEBUG_LOG("%d comment(s)\n", nb_fields);
  92         c += 4;
  93         for (i = 0; i < nb_fields; i++, c += len) {
  94                 char *tag;
  95
  96                 if (c + 4 > end)
  97                         return -E_SPX_COMMENT;
  98                 len = read_u32(c);
  99                 c += 4;
 100                 if (c + len > end)
 101                         return -E_SPX_COMMENT;
 102                 if (copy_if_tag_type(c, len, "author", &tags->artist))
 103                         continue;
 104                 if (copy_if_tag_type(c, len, "artist", &tags->artist))
 105                         continue;
 106                 if (copy_if_tag_type(c, len, "title", &tags->title))
 107                         continue;
 108                 if (copy_if_tag_type(c, len, "album", &tags->album))
 109                         continue;
 110                 if (copy_if_tag_type(c, len, "year", &tags->year))
 111                         continue;
 112                 if (copy_if_tag_type(c, len, "comment", &tags->comment))
 113                         continue;
 114                 tag = safe_strdup(c, len);
 115                 PARA_NOTICE_LOG("unrecognized comment: %s\n", tag);
 116                 free(tag);
 117         }
 118         return 1;
 119 }
 120
 121 static const char* speex_suffixes[] = {"spx", "speex", NULL};
 122
 123 static int spx_packet_callback(ogg_packet *packet, int packet_num,
 124                 __a_unused int serial, struct afh_info *afhi,
 125                 void *private_data)
 126 {
 127         struct private_spx_data *psd = private_data;
 128         int ret;
 129
 130         if (packet_num == 0) {
 131                 ret = spx_process_header(packet->packet, packet->bytes,
 132                         &psd->shi);
 133                 if (ret < 0)
 134                         return ret;
 135                 afhi->channels = psd->shi.channels;
 136                 afhi->frequency = psd->shi.sample_rate;
 137                 afhi->bitrate = psd->shi.bitrate / 1000;
 138                 afhi->techinfo = make_message("%s, v%d", psd->shi.mode->modeName,
 139                         psd->shi.mode->bitstream_version);
 140                 return 1;
 141         }
 142         if (packet_num == 1) {
 143                 ret = spx_get_comments(packet->packet, packet->bytes,
 144                         &afhi->tags);
 145                 if (ret < 0)
 146                         return ret;
 147                 return 0; /* header complete */
 148         }
 149         /* never reached */
 150         return 0;
 151 }
 152
 153 static int spx_get_file_info(char *map, size_t numbytes, __a_unused int fd,
 154                 struct afh_info *afhi)
 155 {
 156         struct private_spx_data psd;
 157         struct ogg_afh_callback_info spx_callback_info = {
 158                 .packet_callback = spx_packet_callback,
 159                 .private_data = &psd,
 160         };
 161
 162         memset(&psd, 0, sizeof(psd));
 163         return ogg_get_file_info(map, numbytes, afhi, &spx_callback_info);
 164 }
 165
 166 static size_t spx_make_meta_packet(struct taginfo *tags, char **result)
 167 {
 168         size_t sz;
 169         char *buf, *p;
 170         size_t comment_len = strlen(tags->comment),
 171                 artist_len = strlen(tags->artist),
 172                 title_len = strlen(tags->title),
 173                 album_len = strlen(tags->album),
 174                 year_len = strlen(tags->year);
 175         uint32_t comment_sz = comment_len,
 176                 artist_sz = artist_len + strlen("artist="),
 177                 title_sz = title_len + strlen("title="),
 178                 album_sz = album_len + strlen("album="),
 179                 year_sz = year_len + strlen("year=");
 180         uint32_t num_tags;
 181
 182         sz = 4 /* comment length (always present) */
 183                 + comment_sz
 184                 + 4; /* number of tags */
 185         num_tags = 0;
 186         if (artist_len) {
 187                 num_tags++;
 188                 sz += 4 + artist_sz;
 189         }
 190         if (title_len) {
 191                 num_tags++;
 192                 sz += 4 + title_sz;
 193         }
 194         if (album_len) {
 195                 num_tags++;
 196                 sz += 4 + album_sz;
 197         }
 198         if (year_len) {
 199                 num_tags++;
 200                 sz += 4 + year_sz;
 201         }
 202         PARA_DEBUG_LOG("meta packet size: %zu bytes\n", sz);
 203         /* terminating zero byte for the last sprintf() */
 204         buf = p = para_malloc(sz + 1);
 205         write_u32(p, comment_sz);
 206         p += 4;
 207         strcpy(p, tags->comment);
 208         p += comment_sz;
 209         write_u32(p, num_tags);
 210         p += 4;
 211         if (artist_len) {
 212                 write_u32(p, artist_sz);
 213                 p += 4;
 214                 sprintf(p, "artist=%s", tags->artist);
 215                 p += artist_sz;
 216         }
 217         if (title_len) {
 218                 write_u32(p, title_sz);
 219                 p += 4;
 220                 sprintf(p, "title=%s", tags->title);
 221                 p += title_sz;
 222         }
 223         if (album_len) {
 224                 write_u32(p, album_sz);
 225                 p += 4;
 226                 sprintf(p, "album=%s", tags->album);
 227                 p += album_sz;
 228         }
 229         if (year_len) {
 230                 write_u32(p, year_sz);
 231                 p += 4;
 232                 sprintf(p, "year=%s", tags->year);
 233                 p += year_sz;
 234         }
 235         assert(p == buf + sz);
 236         *result = buf;
 237         return sz;
 238 }
 239
 240 static int spx_rewrite_tags(const char *map, size_t mapsize,
 241                 struct taginfo *tags, int output_fd,
 242                 __a_unused const char *filename)
 243 {
 244         char *meta_packet;
 245         size_t meta_sz;
 246         int ret;
 247
 248         meta_sz = spx_make_meta_packet(tags, &meta_packet);
 249         ret = ogg_rewrite_tags(map, mapsize, output_fd, meta_packet, meta_sz);
 250         free(meta_packet);
 251         return ret;
 252 }
 253
 254 /**
 255  * The init function of the ogg/speex audio format handler.
 256  *
 257  * \param afh Pointer to the struct to initialize.
 258  */
 259 void spx_afh_init(struct audio_format_handler *afh)
 260 {
 261         afh->get_file_info = spx_get_file_info,
 262         afh->suffixes = speex_suffixes;
 263         afh->rewrite_tags = spx_rewrite_tags;
 264 }