ext/opus/gstopusheader.c

   1 /* GStreamer Opus Encoder
   2  * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
   3  * Copyright (C) <2008> Sebastian Dröge <sebastian.droege@collabora.co.uk>
   4  * Copyright (C) <2011> Vincent Penquerc'h <vincent.penquerch@collabora.co.uk>
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Library General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Library General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Library General Public
  17  * License along with this library; if not, write to the
  18  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19  * Boston, MA 02111-1307, USA.
  20  */
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include "config.h"
  24 #endif
  25 #include <gst/tag/tag.h>
  26 #include <gst/base/gstbytewriter.h>
  27 #include "gstopusheader.h"
  28
  29 static GstBuffer *
  30 gst_opus_enc_create_id_buffer (gint nchannels, gint n_stereo_streams,
  31     gint sample_rate, guint8 channel_mapping_family,
  32     const guint8 * channel_mapping)
  33 {
  34   GstBuffer *buffer;
  35   GstByteWriter bw;
  36
  37   g_return_val_if_fail (nchannels > 0 && nchannels < 256, NULL);
  38   g_return_val_if_fail (n_stereo_streams >= 0, NULL);
  39   g_return_val_if_fail (n_stereo_streams <= nchannels - n_stereo_streams, NULL);
  40
  41   gst_byte_writer_init (&bw);
  42
  43   /* See http://wiki.xiph.org/OggOpus */
  44   gst_byte_writer_put_data (&bw, (const guint8 *) "OpusHead", 8);
  45   gst_byte_writer_put_uint8 (&bw, 0);   /* version number */
  46   gst_byte_writer_put_uint8 (&bw, nchannels);
  47   gst_byte_writer_put_uint16_le (&bw, 0);       /* pre-skip */
  48   gst_byte_writer_put_uint32_le (&bw, sample_rate);
  49   gst_byte_writer_put_uint16_le (&bw, 0);       /* output gain */
  50   gst_byte_writer_put_uint8 (&bw, channel_mapping_family);
  51   if (channel_mapping_family > 0) {
  52     gst_byte_writer_put_uint8 (&bw, nchannels - n_stereo_streams);
  53     gst_byte_writer_put_uint8 (&bw, n_stereo_streams);
  54     gst_byte_writer_put_data (&bw, channel_mapping, nchannels);
  55   }
  56
  57   buffer = gst_byte_writer_reset_and_get_buffer (&bw);
  58
  59   GST_BUFFER_OFFSET (buffer) = 0;
  60   GST_BUFFER_OFFSET_END (buffer) = 0;
  61
  62   return buffer;
  63 }
  64
  65 static GstBuffer *
  66 gst_opus_enc_create_metadata_buffer (const GstTagList * tags)
  67 {
  68   GstTagList *empty_tags = NULL;
  69   GstBuffer *comments = NULL;
  70
  71   GST_DEBUG ("tags = %" GST_PTR_FORMAT, tags);
  72
  73   if (tags == NULL) {
  74     /* FIXME: better fix chain of callers to not write metadata at all,
  75      * if there is none */
  76     empty_tags = gst_tag_list_new_empty ();
  77     tags = empty_tags;
  78   }
  79   comments =
  80       gst_tag_list_to_vorbiscomment_buffer (tags, (const guint8 *) "OpusTags",
  81       8, "Encoded with GStreamer Opusenc");
  82
  83   GST_BUFFER_OFFSET (comments) = 0;
  84   GST_BUFFER_OFFSET_END (comments) = 0;
  85
  86   if (empty_tags)
  87     gst_tag_list_free (empty_tags);
  88
  89   return comments;
  90 }
  91
  92 /*
  93  * (really really) FIXME: move into core (dixit tpm)
  94  */
  95 /**
  96  * _gst_caps_set_buffer_array:
  97  * @caps: a #GstCaps
  98  * @field: field in caps to set
  99  * @buf: header buffers
 100  *
 101  * Adds given buffers to an array of buffers set as the given @field
 102  * on the given @caps.  List of buffer arguments must be NULL-terminated.
 103  *
 104  * Returns: input caps with a streamheader field added, or NULL if some error
 105  */
 106 static GstCaps *
 107 _gst_caps_set_buffer_array (GstCaps * caps, const gchar * field,
 108     GstBuffer * buf, ...)
 109 {
 110   GstStructure *structure = NULL;
 111   va_list va;
 112   GValue array = { 0 };
 113   GValue value = { 0 };
 114
 115   g_return_val_if_fail (caps != NULL, NULL);
 116   g_return_val_if_fail (gst_caps_is_fixed (caps), NULL);
 117   g_return_val_if_fail (field != NULL, NULL);
 118
 119   caps = gst_caps_make_writable (caps);
 120   structure = gst_caps_get_structure (caps, 0);
 121
 122   g_value_init (&array, GST_TYPE_ARRAY);
 123
 124   va_start (va, buf);
 125   /* put buffers in a fixed list */
 126   while (buf) {
 127     g_assert (gst_buffer_is_writable (buf));
 128
 129     /* mark buffer */
 130     GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_IN_CAPS);
 131
 132     g_value_init (&value, GST_TYPE_BUFFER);
 133     buf = gst_buffer_copy (buf);
 134     GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_IN_CAPS);
 135     gst_value_set_buffer (&value, buf);
 136     gst_buffer_unref (buf);
 137     gst_value_array_append_value (&array, &value);
 138     g_value_unset (&value);
 139
 140     buf = va_arg (va, GstBuffer *);
 141   }
 142
 143   gst_structure_set_value (structure, field, &array);
 144   g_value_unset (&array);
 145
 146   return caps;
 147 }
 148
 149 void
 150 gst_opus_header_create_caps_from_headers (GstCaps ** caps, GSList ** headers,
 151     GstBuffer * buf1, GstBuffer * buf2)
 152 {
 153   int n_streams, family;
 154   gboolean multistream;
 155   guint8 *data;
 156   gsize size;
 157
 158   g_return_if_fail (caps);
 159   g_return_if_fail (headers && !*headers);
 160   g_return_if_fail (gst_buffer_get_size (buf1) >= 19);
 161
 162   data = gst_buffer_map (buf1, &size, NULL, GST_MAP_READ);
 163
 164   /* work out the number of streams */
 165   family = data[18];
 166   if (family == 0) {
 167     n_streams = 1;
 168   } else {
 169     /* only included in the header for family > 0 */
 170     if (size >= 20)
 171       n_streams = data[19];
 172     else {
 173       g_warning ("family > 0 but header buffer size < 20");
 174       gst_buffer_unmap (buf1, data, size);
 175       return;
 176     }
 177   }
 178
 179   gst_buffer_unmap (buf1, data, size);
 180
 181   /* mark and put on caps */
 182   multistream = n_streams > 1;
 183   *caps = gst_caps_new_simple ("audio/x-opus",
 184       "multistream", G_TYPE_BOOLEAN, multistream, NULL);
 185   *caps = _gst_caps_set_buffer_array (*caps, "streamheader", buf1, buf2, NULL);
 186
 187   *headers = g_slist_prepend (*headers, buf2);
 188   *headers = g_slist_prepend (*headers, buf1);
 189 }
 190
 191 void
 192 gst_opus_header_create_caps (GstCaps ** caps, GSList ** headers, gint nchannels,
 193     gint n_stereo_streams, gint sample_rate, guint8 channel_mapping_family,
 194     const guint8 * channel_mapping, const GstTagList * tags)
 195 {
 196   GstBuffer *buf1, *buf2;
 197
 198   g_return_if_fail (caps);
 199   g_return_if_fail (headers && !*headers);
 200   g_return_if_fail (nchannels > 0);
 201   g_return_if_fail (sample_rate >= 0);  /* 0 -> unset */
 202   g_return_if_fail (channel_mapping_family == 0 || channel_mapping);
 203
 204   /* Opus streams in Ogg begin with two headers; the initial header (with
 205      most of the codec setup parameters) which is mandated by the Ogg
 206      bitstream spec.  The second header holds any comment fields. */
 207
 208   /* create header buffers */
 209   buf1 =
 210       gst_opus_enc_create_id_buffer (nchannels, n_stereo_streams, sample_rate,
 211       channel_mapping_family, channel_mapping);
 212   buf2 = gst_opus_enc_create_metadata_buffer (tags);
 213
 214   gst_opus_header_create_caps_from_headers (caps, headers, buf1, buf2);
 215 }
 216
 217 gboolean
 218 gst_opus_header_is_header (GstBuffer * buf, const char *magic, guint magic_size)
 219 {
 220   return (gst_buffer_get_size (buf) >= magic_size
 221       && !gst_buffer_memcmp (buf, 0, magic, magic_size));
 222 }
 223
 224 gboolean
 225 gst_opus_header_is_id_header (GstBuffer * buf)
 226 {
 227   gsize size = gst_buffer_get_size (buf);
 228   guint8 *data = NULL;
 229   guint8 channels, channel_mapping_family, n_streams, n_stereo_streams;
 230   gboolean ret = FALSE;
 231
 232   if (size < 19)
 233     goto beach;
 234   if (!gst_opus_header_is_header (buf, "OpusHead", 8))
 235     goto beach;
 236
 237   data = gst_buffer_map (buf, &size, NULL, GST_MAP_READ);
 238
 239   channels = data[9];
 240
 241   if (channels == 0)
 242     goto beach;
 243
 244   channel_mapping_family = data[18];
 245
 246   if (channel_mapping_family == 0) {
 247     if (channels > 2)
 248       goto beach;
 249   } else {
 250     channels = data[9];
 251     if (size < 21 + channels)
 252       goto beach;
 253     n_streams = data[19];
 254     n_stereo_streams = data[20];
 255     if (n_streams == 0)
 256       goto beach;
 257     if (n_stereo_streams > n_streams)
 258       goto beach;
 259     if (n_streams + n_stereo_streams > 255)
 260       goto beach;
 261   }
 262   ret = TRUE;
 263
 264 beach:
 265   if (data)
 266     gst_buffer_unmap (buf, data, size);
 267   return ret;
 268 }
 269
 270 gboolean
 271 gst_opus_header_is_comment_header (GstBuffer * buf)
 272 {
 273   return gst_opus_header_is_header (buf, "OpusTags", 8);
 274 }