spx_afh.c

   1 /*
   2  * Copyright (C) 2010-2013 Andre Noll <maan@systemlinux.org>
   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 /**
 167  * The init function of the ogg/speex audio format handler.
 168  *
 169  * \param afh Pointer to the struct to initialize.
 170  */
 171 void spx_afh_init(struct audio_format_handler *afh)
 172 {
 173         afh->get_file_info = spx_get_file_info,
 174         afh->suffixes = speex_suffixes;
 175 }