swfdec/swfdec_audio.c

   1 /* Swfdec
   2  * Copyright (C) 2003-2006 David Schleef <ds@schleef.org>
   3  *               2005-2006 Eric Anholt <eric@anholt.net>
   4  *               2006-2008 Benjamin Otte <otte@gnome.org>
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 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  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor,
  19  * Boston, MA  02110-1301  USA
  20  */
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include "config.h"
  24 #endif
  25
  26 #include <string.h>
  27 #include "swfdec_audio_internal.h"
  28 #include "swfdec_actor.h"
  29 #include "swfdec_debug.h"
  30 #include "swfdec_player_internal.h"
  31
  32 /**
  33  * SECTION:SwfdecAudio
  34  * @title: SwfdecAudio
  35  * @see_also: SwfdecPlayer
  36  * @short_description: object used for audio output
  37  *
  38  * SwfdecAudio is the way audio output is provided by a #SwfdecPlayer. See
  39  * its documentation on how to access #SwfdecAudio objects.
  40  *
  41  * An audio object gives access to one audio stream played inside a player.
  42  * You are responsible for outputting this data, swfdec does not try to do this
  43  * for you.
  44  *
  45  * Audio data is always provided in 16bit host-endian stereo. If the data was
  46  * encoded into a different format originally, Swfdec will already have decoded
  47  * it. The data is always referenced relative to the player. Sample 0
  48  * references the first sample to be played at the current position. If the
  49  * player gets iterated, sample 0 changes. There is no way to access samples
  50  * belonging to a previous state.
  51  */
  52
  53 /**
  54  * SwfdecAudio
  55  *
  56  * This object is used for audio output. It is an abstract class.
  57  */
  58
  59 G_DEFINE_ABSTRACT_TYPE (SwfdecAudio, swfdec_audio, G_TYPE_OBJECT)
  60
  61 enum {
  62   CHANGED,
  63   NEW_DATA,
  64   LAST_SIGNAL
  65 };
  66
  67 static guint signals[LAST_SIGNAL] = { 0, };
  68
  69 static void
  70 swfdec_audio_dispose (GObject *object)
  71 {
  72   SwfdecAudio *audio = SWFDEC_AUDIO (object);
  73
  74   g_assert (audio->actor == NULL);
  75   g_assert (audio->player == NULL);
  76
  77   G_OBJECT_CLASS (swfdec_audio_parent_class)->dispose (object);
  78 }
  79
  80 static void
  81 swfdec_audio_class_init (SwfdecAudioClass *klass)
  82 {
  83   GObjectClass *object_class = G_OBJECT_CLASS (klass);
  84
  85   /**
  86    * SwfdecAudio::changed:
  87    * @audio: the #SwfdecAudio affected
  88    *
  89    * This signal is emitted whenever the data of the @audio changed and cached
  90    * data should be rerendered. This happens for example when the volume of the
  91    * audio is changed by the Flash file.
  92    */
  93   signals[CHANGED] = g_signal_new ("changed", G_TYPE_FROM_CLASS (klass),
  94       G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__VOID,
  95       G_TYPE_NONE, 0);
  96   /**
  97    * SwfdecAudio::new-data:
  98    * @audio: the #SwfdecAudio affected
  99    *
 100    * This signal is emitted whenever new data was loaded into @audio. You want
 101    * to listen to this signal when swfdec_audio_render() previously returned
 102    * less samples than you wanted to render.
 103    */
 104   signals[NEW_DATA] = g_signal_new ("new-data", G_TYPE_FROM_CLASS (klass),
 105       G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__VOID,
 106       G_TYPE_NONE, 0);
 107
 108   object_class->dispose = swfdec_audio_dispose;
 109 }
 110
 111 static void
 112 swfdec_audio_init (SwfdecAudio *audio)
 113 {
 114 }
 115
 116 /**
 117  * swfdec_audio_add:
 118  * @audio: audio to add
 119  * @player: a #SwfdecPlayer to attach to or NULL
 120  *
 121  * Registers a new audio object for playback in @player. If player is %NULL,
 122  * this function does nothing.
 123  * The starting point of the audio stream will be equivalent the player's time.
 124  **/
 125 void
 126 swfdec_audio_add (SwfdecAudio *audio, SwfdecPlayer *player)
 127 {
 128   SwfdecPlayerPrivate *priv;
 129
 130   g_return_if_fail (SWFDEC_IS_AUDIO (audio));
 131   g_return_if_fail (audio->player == NULL);
 132   if (player == NULL)
 133     return;
 134   g_return_if_fail (SWFDEC_IS_PLAYER (player));
 135
 136   g_object_ref (audio);
 137   audio->player = player;
 138   priv = player->priv;
 139   priv->audio = g_list_append (priv->audio, audio);
 140   SWFDEC_INFO ("adding %s %p", G_OBJECT_TYPE_NAME (audio), audio);
 141 }
 142
 143 void
 144 swfdec_audio_remove (SwfdecAudio *audio)
 145 {
 146   g_return_if_fail (SWFDEC_IS_AUDIO (audio));
 147
 148   if (audio->player != NULL) {
 149     SwfdecPlayerPrivate *priv = audio->player->priv;
 150     SWFDEC_INFO ("removing %s %p", G_OBJECT_TYPE_NAME (audio), audio);
 151     swfdec_audio_set_actor (audio, NULL);
 152     priv->audio = g_list_remove (priv->audio, audio);
 153     if (audio->added) {
 154       g_signal_emit_by_name (audio->player, "audio-removed", audio);
 155       audio->added = FALSE;
 156     }
 157     audio->player = NULL;
 158     g_object_unref (audio);
 159   }
 160 }
 161
 162 /**
 163  * swfdec_audio_iterate:
 164  * @audio: the #SwfdecAudio to iterate
 165  * @n_samples: number of samples to remove
 166  *
 167  * Iterates the @audio. Iterating means discarding the first @n_samples
 168  * samples of the audio stream.
 169  *
 170  * Returns: maximum number of remaining frames. If G_MAXUINT is returned,
 171  *          then the number of frames isn't known yet.
 172  **/
 173 gsize
 174 swfdec_audio_iterate (SwfdecAudio *audio, gsize n_samples)
 175 {
 176   SwfdecAudioClass *klass;
 177
 178   g_return_val_if_fail (SWFDEC_IS_AUDIO (audio), 0);
 179   g_return_val_if_fail (n_samples > 0, 0);
 180
 181   klass = SWFDEC_AUDIO_GET_CLASS (audio);
 182   g_assert (klass->iterate);
 183   return klass->iterate (audio, n_samples);
 184 }
 185
 186 void
 187 swfdec_audio_set_actor (SwfdecAudio *audio, SwfdecActor *actor)
 188 {
 189   g_return_if_fail (SWFDEC_IS_AUDIO (audio));
 190   g_return_if_fail (audio->player != NULL);
 191   g_return_if_fail (actor == NULL || SWFDEC_IS_ACTOR (actor));
 192
 193   if (actor) {
 194     g_object_ref (actor);
 195   }
 196   if (audio->actor) {
 197     g_object_unref (audio->actor);
 198   }
 199   audio->actor = actor;
 200   swfdec_audio_set_matrix (audio, actor ? &actor->sound_matrix : NULL);
 201 }
 202
 203 void
 204 swfdec_audio_set_matrix (SwfdecAudio *audio, const SwfdecSoundMatrix *matrix)
 205 {
 206   g_return_if_fail (SWFDEC_IS_AUDIO (audio));
 207
 208   audio->matrix = matrix;
 209 }
 210
 211 /* FIXME: This function is pretty much a polling approach at sound matrix
 212  * handling and it would be much nicer if we had a "changed" signal on the
 213  * matrices. But matrices can't emit signals...
 214  */
 215 void
 216 swfdec_audio_update_matrix (SwfdecAudio *audio)
 217 {
 218   SwfdecSoundMatrix sound;
 219
 220   g_return_if_fail (SWFDEC_IS_AUDIO (audio));
 221
 222   if (audio->matrix) {
 223     swfdec_sound_matrix_multiply (&sound, audio->matrix,
 224         &audio->player->priv->sound_matrix);
 225   } else if (audio->player) {
 226     sound = audio->player->priv->sound_matrix;
 227   }
 228   if (swfdec_sound_matrix_is_equal (&sound, &audio->matrix_cache))
 229     return;
 230
 231   audio->matrix_cache = sound;
 232   g_signal_emit (audio, signals[CHANGED], 0);
 233 }
 234
 235 /**
 236  * swfdec_audio_render:
 237  * @audio: a #SwfdecAudio
 238  * @dest: memory area to render to
 239  * @start_offset: offset in samples at which to start rendering. The offset is
 240  *                calculated relative to the last iteration, so the value set
 241  *                by swfdec_player_set_audio_advance() is ignored.
 242  * @n_samples: amount of samples to render.
 243  *
 244  * Renders the samples from @audio into the area pointed to by @dest. Existing
 245  * data in @dest is overwritten.
 246  *
 247  * Returns: The amount of samples actually rendered. Usually this number is
 248  *          equal to @n_samples, but if you arrived at the end of stream or the
 249  *          stream is still loading, this number may be lower. It indicates
 250  *          that no more samples are available.
 251  **/
 252 gsize
 253 swfdec_audio_render (SwfdecAudio *audio, gint16 *dest,
 254     gsize start_offset, gsize n_samples)
 255 {
 256   SwfdecAudioClass *klass;
 257   guint rendered;
 258
 259   g_return_val_if_fail (SWFDEC_IS_AUDIO (audio), 0);
 260   g_return_val_if_fail (dest != NULL, 0);
 261   g_return_val_if_fail (n_samples > 0, 0);
 262
 263   klass = SWFDEC_AUDIO_GET_CLASS (audio);
 264   rendered = klass->render (audio, dest, start_offset, n_samples);
 265   swfdec_sound_matrix_apply (&audio->matrix_cache, dest, rendered);
 266
 267   return rendered;
 268 }
 269
 270 /*** SWFDEC_AUDIO_FORMAT ***/
 271
 272 /* SwfdecAudioFormat is represented in the least significant bits of a uint:
 273  * - the LSBit is 1 if it's 16bit audio, 0 for 8bit
 274  * - the next bit is 1 for stereo, 0 for mono
 275  * - the other two bits are for the rate, see swfdec_audio_format_new()
 276  * This is the same format the Flash file format uses to store audio formats.
 277  */
 278
 279 SwfdecAudioFormat
 280 swfdec_audio_format_parse (SwfdecBits *bits)
 281 {
 282   g_return_val_if_fail (bits != NULL, 0);
 283
 284   return swfdec_bits_getbits (bits, 4);
 285 }
 286
 287 SwfdecAudioFormat
 288 swfdec_audio_format_new (guint rate, guint channels, gboolean is_16bit)
 289 {
 290   SwfdecAudioFormat ret;
 291
 292   g_return_val_if_fail (channels == 1 || channels == 2, 0);
 293
 294   switch (rate) {
 295     case 44100:
 296       ret = 3 << 2;
 297       break;
 298     case 22050:
 299       ret = 2 << 2;
 300       break;
 301     case 11025:
 302       ret = 1 << 2;
 303       break;
 304     case 5512:
 305       ret = 0 << 2;
 306       break;
 307     default:
 308       g_return_val_if_reached (0);
 309       break;
 310   }
 311   if (is_16bit)
 312     ret |= 2;
 313   if (channels == 2)
 314     ret |= 1;
 315
 316   return ret;
 317 }
 318
 319 guint
 320 swfdec_audio_format_get_channels (SwfdecAudioFormat format)
 321 {
 322   g_return_val_if_fail (SWFDEC_IS_AUDIO_FORMAT (format), 2);
 323
 324   return (format & 0x1) + 1;
 325 }
 326
 327 gboolean
 328 swfdec_audio_format_is_16bit (SwfdecAudioFormat format)
 329 {
 330   g_return_val_if_fail (SWFDEC_IS_AUDIO_FORMAT (format), TRUE);
 331
 332   return format & 0x2 ? TRUE : FALSE;
 333 }
 334
 335 guint
 336 swfdec_audio_format_get_rate (SwfdecAudioFormat format)
 337 {
 338   g_return_val_if_fail (SWFDEC_IS_AUDIO_FORMAT (format), 44100);
 339
 340   return 44100 / swfdec_audio_format_get_granularity (format);
 341 }
 342
 343 /**
 344  * swfdec_audio_format_get_granularity:
 345  * @format: an auio format
 346  *
 347  * The granularity is a Swfdec-specific name, describing how often a sample in
 348  * a 44100Hz audio stream is defined. So for example 44100Hz has a granularity
 349  * of 1 and 11025Hz has a granularity of 4 (because only every fourth sample
 350  * is defined).
 351  *
 352  * Returns: the granularity of the format
 353  **/
 354 guint
 355 swfdec_audio_format_get_granularity (SwfdecAudioFormat format)
 356 {
 357   g_return_val_if_fail (SWFDEC_IS_AUDIO_FORMAT (format), 1);
 358
 359   return 1 << (3 - (format >> 2));
 360 }
 361
 362 const char *
 363 swfdec_audio_format_to_string (SwfdecAudioFormat format)
 364 {
 365   static const char *names[] = {
 366     "8bit 5.5kHz mono",
 367     "8bit 5.5kHz stereo",
 368     "16bit 5.5kHz mono",
 369     "16bit 5.5kHz stereo",
 370     "8bit 11kHz mono",
 371     "8bit 11kHz stereo",
 372     "16bit 11kHz mono",
 373     "16bit 11kHz stereo",
 374     "8bit 22kHz mono",
 375     "8bit 22kHz stereo",
 376     "16bit 22kHz mono",
 377     "16bit 22kHz stereo",
 378     "8bit 44kHz mono",
 379     "8bit 44kHz stereo",
 380     "16bit 44kHz mono",
 381     "16bit 44kHz stereo"
 382   };
 383   g_return_val_if_fail (SWFDEC_IS_AUDIO_FORMAT (format), "");
 384
 385   return names[format];
 386 }
 387
 388 /**
 389  * swfdec_audio_format_get_bytes_per_sample:
 390  * @format: audio format to check
 391  *
 392  * Computes the number of bytes required to store one sample of audio encoded
 393  * in @format.
 394  *
 395  * Returns: The number of bytes for one sample
 396  **/
 397 guint
 398 swfdec_audio_format_get_bytes_per_sample (SwfdecAudioFormat format)
 399 {
 400   guint bps[4] = { 1, 2, 2, 4 };
 401
 402   g_return_val_if_fail (SWFDEC_IS_AUDIO_FORMAT (format), 1);
 403
 404   return bps [format & 0x3];
 405 }
 406