subprojects/gst-plugins-bad/gst/adpcmdec/adpcmdec.c

   1 /* GStreamer
   2  * Copyright (C) 2009 Pioneers of the Inevitable <songbird@songbirdnest.com>
   3  *
   4  * Authors: Michael Smith <msmith@songbirdnest.com>
   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., 51 Franklin St, Fifth Floor,
  19  * Boston, MA 02110-1301, USA.
  20  */
  21
  22 /* Based on ADPCM decoders in libsndfile,
  23    Copyright (C) 1999-2002 Erik de Castro Lopo <erikd@zip.com.au
  24  */
  25
  26 #ifdef HAVE_CONFIG_H
  27 #include "config.h"
  28 #endif
  29
  30 #include <gst/gst.h>
  31 #include <gst/audio/gstaudiodecoder.h>
  32
  33 #define GST_TYPE_ADPCM_DEC \
  34     (adpcmdec_get_type ())
  35
  36 #define GST_ADPCM_DEC(obj) \
  37     (G_TYPE_CHECK_INSTANCE_CAST ((obj), GST_TYPE_ADPCM_DEC, ADPCMDec))
  38
  39 #define GST_CAT_DEFAULT adpcmdec_debug
  40 GST_DEBUG_CATEGORY_STATIC (adpcmdec_debug);
  41
  42 static GstStaticPadTemplate adpcmdec_sink_template =
  43     GST_STATIC_PAD_TEMPLATE ("sink",
  44     GST_PAD_SINK,
  45     GST_PAD_ALWAYS,
  46     GST_STATIC_CAPS ("audio/x-adpcm, "
  47         " layout=(string){microsoft, dvi}, "
  48         " block_align = (int) [64, 8192], "
  49         " rate = (int)[ 1, MAX ], " "channels = (int)[1,2];")
  50     );
  51
  52 static GstStaticPadTemplate adpcmdec_src_template =
  53 GST_STATIC_PAD_TEMPLATE ("src",
  54     GST_PAD_SRC,
  55     GST_PAD_ALWAYS,
  56     GST_STATIC_CAPS ("audio/x-raw, "
  57         "format = (string) " GST_AUDIO_NE (S16) ", "
  58         "layout = (string) interleaved, "
  59         "rate = (int) [1, MAX], channels = (int) [1,2]")
  60     );
  61
  62 enum adpcm_layout
  63 {
  64   LAYOUT_ADPCM_MICROSOFT,
  65   LAYOUT_ADPCM_DVI
  66 };
  67
  68 typedef struct _ADPCMDecClass
  69 {
  70   GstAudioDecoderClass parent_class;
  71 } ADPCMDecClass;
  72
  73 typedef struct _ADPCMDec
  74 {
  75   GstAudioDecoder parent;
  76
  77   enum adpcm_layout layout;
  78   int rate;
  79   int channels;
  80   int blocksize;
  81 } ADPCMDec;
  82
  83 GType adpcmdec_get_type (void);
  84 GST_ELEMENT_REGISTER_DECLARE (adpcmdec);
  85 G_DEFINE_TYPE_WITH_CODE (ADPCMDec, adpcmdec, GST_TYPE_AUDIO_DECODER,
  86     GST_DEBUG_CATEGORY_INIT (adpcmdec_debug, "adpcmdec", 0, "ADPCM Decoders");
  87     );
  88 GST_ELEMENT_REGISTER_DEFINE (adpcmdec, "adpcmdec", GST_RANK_PRIMARY,
  89     GST_TYPE_ADPCM_DEC);
  90
  91 static gboolean
  92 adpcmdec_set_format (GstAudioDecoder * bdec, GstCaps * in_caps)
  93 {
  94   ADPCMDec *dec = (ADPCMDec *) (bdec);
  95   GstStructure *structure = gst_caps_get_structure (in_caps, 0);
  96   const gchar *layout;
  97   GstAudioInfo info;
  98
  99   layout = gst_structure_get_string (structure, "layout");
 100   if (!layout)
 101     return FALSE;
 102
 103   if (g_str_equal (layout, "microsoft"))
 104     dec->layout = LAYOUT_ADPCM_MICROSOFT;
 105   else if (g_str_equal (layout, "dvi"))
 106     dec->layout = LAYOUT_ADPCM_DVI;
 107   else
 108     return FALSE;
 109
 110   if (!gst_structure_get_int (structure, "block_align", &dec->blocksize))
 111     dec->blocksize = -1;        /* Not provided */
 112
 113   if (!gst_structure_get_int (structure, "rate", &dec->rate))
 114     return FALSE;
 115   if (!gst_structure_get_int (structure, "channels", &dec->channels))
 116     return FALSE;
 117
 118   gst_audio_info_init (&info);
 119   gst_audio_info_set_format (&info, GST_AUDIO_FORMAT_S16, dec->rate,
 120       dec->channels, NULL);
 121
 122   gst_audio_decoder_set_output_format (bdec, &info);
 123   return TRUE;
 124 }
 125
 126
 127 /*=====================================================================
 128  * From libsndfile:
 129  *
 130  *  MS ADPCM Block Layout.
 131  *  ======================
 132  *  Block is usually 256, 512 or 1024 bytes depending on sample rate.
 133  *  For a mono file, the block is laid out as follows:
 134  *      byte    purpose
 135  *      0       block predictor [0..6]
 136  *      1,2     initial idelta (positive)
 137  *      3,4     sample 1
 138  *      5,6     sample 0
 139  *      7..n    packed bytecodes
 140  *
 141  *  For a stereo file, the block is laid out as follows:
 142  *      byte    purpose
 143  *      0       block predictor [0..6] for left channel
 144  *      1       block predictor [0..6] for right channel
 145  *      2,3     initial idelta (positive) for left channel
 146  *      4,5     initial idelta (positive) for right channel
 147  *      6,7     sample 1 for left channel
 148  *      8,9     sample 1 for right channel
 149  *      10,11   sample 0 for left channel
 150  *      12,13   sample 0 for right channel
 151  *      14..n   packed bytecodes
 152  *
 153  *=====================================================================
 154 */
 155 static const int AdaptationTable[] = {
 156   230, 230, 230, 230, 307, 409, 512, 614,
 157   768, 614, 512, 409, 307, 230, 230, 230
 158 };
 159
 160 static const int AdaptCoeff1[] = {
 161   256, 512, 0, 192, 240, 460, 392
 162 };
 163
 164 static const int AdaptCoeff2[] = {
 165   0, -256, 0, 64, 0, -208, -232
 166 };
 167
 168 static gint16
 169 read_sample (const guint8 * data)
 170 {
 171   guint16 val = data[0] | (data[1] << 8);
 172   return *((gint16 *) & val);
 173 }
 174
 175 /* Decode a single block of data from 'data', storing 'n_samples' decoded 16 bit
 176    samples in 'samples'.
 177
 178    All buffer lengths have been verified by the caller
 179  */
 180 static gboolean
 181 adpcmdec_decode_ms_block (ADPCMDec * dec, int n_samples, const guint8 * data,
 182     gint16 * samples)
 183 {
 184   gint16 pred[2];
 185   gint16 idelta[2];
 186   int idx;                      /* Current byte offset in 'data' */
 187   int i;                        /* Current sample index in 'samples' */
 188
 189   /* Read the block header, verify for sanity */
 190   if (dec->channels == 1) {
 191     pred[0] = data[0];
 192     idelta[0] = read_sample (data + 1);
 193     samples[1] = read_sample (data + 3);
 194     samples[0] = read_sample (data + 5);
 195     idx = 7;
 196     i = 2;
 197     if (pred[0] < 0 || pred[0] > 6) {
 198       GST_WARNING_OBJECT (dec, "Invalid block predictor");
 199       return FALSE;
 200     }
 201   }
 202
 203   else {
 204     pred[0] = data[0];
 205     pred[1] = data[1];
 206     idelta[0] = read_sample (data + 2);
 207     idelta[1] = read_sample (data + 4);
 208     samples[2] = read_sample (data + 6);
 209     samples[3] = read_sample (data + 8);
 210     samples[0] = read_sample (data + 10);
 211     samples[1] = read_sample (data + 12);
 212     idx = 14;
 213     i = 4;
 214     if (pred[0] < 0 || pred[0] > 6 || pred[1] < 0 || pred[1] > 6) {
 215       GST_WARNING_OBJECT (dec, "Invalid block predictor");
 216       return FALSE;
 217     }
 218   }
 219   for (; i < n_samples; i++) {
 220     int chan = i % dec->channels;
 221     int bytecode;
 222     int delta;
 223     int current;
 224     int predict;
 225     if (i % 2 == 0) {
 226       bytecode = (data[idx] >> 4) & 0x0F;
 227     } else {
 228       bytecode = data[idx] & 0x0F;
 229       idx++;
 230     }
 231
 232     delta = idelta[chan];
 233     idelta[chan] = (AdaptationTable[bytecode] * delta) >> 8;
 234     if (idelta[chan] < 16)
 235       idelta[chan] = 16;
 236
 237     /* Bytecode is used above as an index into the table. Below, it's used
 238        as a signed 4-bit value; convert appropriately */
 239     if (bytecode & 0x8)
 240       bytecode -= 0x10;
 241
 242     predict = ((samples[i - dec->channels] * AdaptCoeff1[pred[chan]]) +
 243         (samples[i - 2 * dec->channels] * AdaptCoeff2[pred[chan]])
 244         ) >> 8;
 245
 246     current = (bytecode * delta) + predict;
 247
 248     /* Clamp to 16 bits, store decoded sample */
 249     samples[i] = CLAMP (current, G_MININT16, G_MAXINT16);
 250   }
 251   return TRUE;
 252 }
 253
 254 static const int ima_indx_adjust[16] = {
 255   -1, -1, -1, -1, 2, 4, 6, 8, -1, -1, -1, -1, 2, 4, 6, 8,
 256 };
 257
 258 static const int ima_step_size[89] = {
 259   7, 8, 9, 10, 11, 12, 13, 14, 16, 17, 19, 21, 23, 25, 28, 31, 34, 37, 41, 45,
 260   50, 55, 60, 66, 73, 80, 88, 97, 107, 118, 130, 143, 157, 173, 190, 209, 230,
 261   253, 279, 307, 337, 371, 408, 449, 494, 544, 598, 658, 724, 796, 876, 963,
 262   1060, 1166, 1282, 1411, 1552, 1707, 1878, 2066, 2272, 2499, 2749, 3024, 3327,
 263   3660, 4026, 4428, 4871, 5358, 5894, 6484, 7132, 7845, 8630, 9493, 10442,
 264   11487, 12635, 13899, 15289, 16818, 18500, 20350, 22385, 24623, 27086, 29794,
 265   32767
 266 };
 267
 268 /* Decode a single block of data from 'data', storing 'n_samples' decoded 16 bit
 269    samples in 'samples'.
 270
 271    All buffer lengths have been verified by the caller
 272  */
 273 static gboolean
 274 adpcmdec_decode_ima_block (ADPCMDec * dec, int n_samples, const guint8 * data,
 275     gint16 * samples)
 276 {
 277   gint16 stepindex[2];
 278   int channel;
 279   int idx;
 280   int i, j;
 281   int sample;
 282
 283   if ((n_samples - dec->channels) % 8 != 0) {
 284     GST_WARNING_OBJECT (dec, "Input not correct size");
 285     return FALSE;
 286   }
 287
 288   for (channel = 0; channel < dec->channels; channel++) {
 289     samples[channel] = read_sample (data + channel * 4);
 290     stepindex[channel] = MIN (data[channel * 4 + 2], 88);
 291
 292     if (data[channel * 4 + 3] != 0) {
 293       GST_WARNING_OBJECT (dec, "Synchronisation error");
 294       return FALSE;
 295     }
 296   }
 297
 298   i = dec->channels;
 299   idx = 4 * dec->channels;
 300
 301   while (i < n_samples) {
 302     for (channel = 0; channel < dec->channels; channel++) {
 303       sample = i + channel;
 304       for (j = 0; j < 8; j++) {
 305         int bytecode;
 306         int step;
 307         int diff;
 308
 309         if (j % 2 == 0) {
 310           bytecode = data[idx] & 0x0F;
 311         } else {
 312           bytecode = (data[idx] >> 4) & 0x0F;
 313           idx++;
 314         }
 315         step = ima_step_size[stepindex[channel]];
 316         diff = (2 * (bytecode & 0x7) * step + step) / 8;
 317         if (bytecode & 8)
 318           diff = -diff;
 319
 320         samples[sample] =
 321             CLAMP (samples[sample - dec->channels] + diff, G_MININT16,
 322             G_MAXINT16);
 323         stepindex[channel] =
 324             CLAMP (stepindex[channel] + ima_indx_adjust[bytecode], 0, 88);
 325         sample += dec->channels;
 326       }
 327     }
 328     i += 8 * dec->channels;
 329   }
 330   return TRUE;
 331 }
 332
 333 static GstBuffer *
 334 adpcmdec_decode_block (ADPCMDec * dec, const guint8 * data, int blocksize)
 335 {
 336   gboolean res = FALSE;
 337   GstBuffer *outbuf = NULL;
 338   int outsize;
 339   int samples;
 340   GstMapInfo omap;
 341
 342   if (dec->layout == LAYOUT_ADPCM_MICROSOFT) {
 343     /* Each block has a 3 byte header per channel, plus 4 bytes per channel to
 344        give two initial sample values per channel. Then the remainder gives
 345        two samples per byte */
 346     if (blocksize < 7 * dec->channels)
 347       goto exit;
 348     samples = (blocksize - 7 * dec->channels) * 2 + 2 * dec->channels;
 349     outsize = 2 * samples;
 350     outbuf = gst_buffer_new_and_alloc (outsize);
 351
 352     gst_buffer_map (outbuf, &omap, GST_MAP_WRITE);
 353     res = adpcmdec_decode_ms_block (dec, samples, data, (gint16 *) omap.data);
 354     gst_buffer_unmap (outbuf, &omap);
 355   } else if (dec->layout == LAYOUT_ADPCM_DVI) {
 356     /* Each block has a 4 byte header per channel, include an initial sample.
 357        Then the remainder gives two samples per byte */
 358     if (blocksize < 4 * dec->channels)
 359       goto exit;
 360     samples = (blocksize - 4 * dec->channels) * 2 + dec->channels;
 361     outsize = 2 * samples;
 362     outbuf = gst_buffer_new_and_alloc (outsize);
 363
 364     gst_buffer_map (outbuf, &omap, GST_MAP_WRITE);
 365     res = adpcmdec_decode_ima_block (dec, samples, data, (gint16 *) omap.data);
 366     gst_buffer_unmap (outbuf, &omap);
 367   } else {
 368     GST_WARNING_OBJECT (dec, "Unknown layout");
 369   }
 370
 371   if (!res) {
 372     if (outbuf)
 373       gst_buffer_unref (outbuf);
 374     outbuf = NULL;
 375     GST_WARNING_OBJECT (dec, "Decode of block failed");
 376   }
 377
 378 exit:
 379   return outbuf;
 380 }
 381
 382 static GstFlowReturn
 383 adpcmdec_parse (GstAudioDecoder * bdec, GstAdapter * adapter,
 384     gint * offset, gint * length)
 385 {
 386   ADPCMDec *dec = (ADPCMDec *) (bdec);
 387   guint size;
 388
 389   size = gst_adapter_available (adapter);
 390   g_return_val_if_fail (size > 0, GST_FLOW_ERROR);
 391
 392   if (dec->blocksize < 0) {
 393     /* No explicit blocksize; we just process one input buffer at a time */
 394     *offset = 0;
 395     *length = size;
 396   } else {
 397     if (size >= dec->blocksize) {
 398       *offset = 0;
 399       *length = dec->blocksize;
 400     } else {
 401       return GST_FLOW_EOS;
 402     }
 403   }
 404
 405   return GST_FLOW_OK;
 406 }
 407
 408 static GstFlowReturn
 409 adpcmdec_handle_frame (GstAudioDecoder * bdec, GstBuffer * buffer)
 410 {
 411   ADPCMDec *dec = (ADPCMDec *) (bdec);
 412   GstFlowReturn ret = GST_FLOW_OK;
 413   GstMapInfo map;
 414   GstBuffer *outbuf = NULL;
 415
 416   /* no fancy draining */
 417   if (G_UNLIKELY (!buffer))
 418     return GST_FLOW_OK;
 419
 420   if (!dec->blocksize)
 421     return GST_FLOW_NOT_NEGOTIATED;
 422
 423   gst_buffer_map (buffer, &map, GST_MAP_READ);
 424   outbuf = adpcmdec_decode_block (dec, map.data, dec->blocksize);
 425   gst_buffer_unmap (buffer, &map);
 426
 427   if (outbuf == NULL) {
 428     GST_AUDIO_DECODER_ERROR (bdec, 1, STREAM, DECODE, (NULL),
 429         ("frame decode failed"), ret);
 430   }
 431
 432   if (ret == GST_FLOW_OK)
 433     ret = gst_audio_decoder_finish_frame (bdec, outbuf, 1);
 434
 435   return ret;
 436 }
 437
 438 static gboolean
 439 adpcmdec_start (GstAudioDecoder * bdec)
 440 {
 441   ADPCMDec *dec = (ADPCMDec *) bdec;
 442
 443   GST_DEBUG_OBJECT (dec, "start");
 444
 445   dec->blocksize = 0;
 446   dec->rate = 0;
 447   dec->channels = 0;
 448
 449   return TRUE;
 450 }
 451
 452 static gboolean
 453 adpcmdec_stop (GstAudioDecoder * dec)
 454 {
 455   GST_DEBUG_OBJECT (dec, "stop");
 456
 457   return TRUE;
 458 }
 459
 460 static void
 461 adpcmdec_init (ADPCMDec * dec)
 462 {
 463   gst_audio_decoder_set_needs_format (GST_AUDIO_DECODER (dec), TRUE);
 464   gst_audio_decoder_set_use_default_pad_acceptcaps (GST_AUDIO_DECODER_CAST
 465       (dec), TRUE);
 466   GST_PAD_SET_ACCEPT_TEMPLATE (GST_AUDIO_DECODER_SINK_PAD (dec));
 467 }
 468
 469 static void
 470 adpcmdec_class_init (ADPCMDecClass * klass)
 471 {
 472   GstElementClass *element_class = (GstElementClass *) klass;
 473   GstAudioDecoderClass *base_class = (GstAudioDecoderClass *) klass;
 474
 475   gst_element_class_add_static_pad_template (element_class,
 476       &adpcmdec_sink_template);
 477   gst_element_class_add_static_pad_template (element_class,
 478       &adpcmdec_src_template);
 479   gst_element_class_set_static_metadata (element_class, "ADPCM decoder",
 480       "Codec/Decoder/Audio", "Decode MS and IMA ADPCM audio",
 481       "Pioneers of the Inevitable <songbird@songbirdnest.com>");
 482
 483   base_class->start = GST_DEBUG_FUNCPTR (adpcmdec_start);
 484   base_class->stop = GST_DEBUG_FUNCPTR (adpcmdec_stop);
 485   base_class->set_format = GST_DEBUG_FUNCPTR (adpcmdec_set_format);
 486   base_class->parse = GST_DEBUG_FUNCPTR (adpcmdec_parse);
 487   base_class->handle_frame = GST_DEBUG_FUNCPTR (adpcmdec_handle_frame);
 488 }
 489
 490 static gboolean
 491 plugin_init (GstPlugin * plugin)
 492 {
 493   return GST_ELEMENT_REGISTER (adpcmdec, plugin);
 494 }
 495
 496 GST_PLUGIN_DEFINE (GST_VERSION_MAJOR, GST_VERSION_MINOR, adpcmdec,
 497     "ADPCM decoder", plugin_init, VERSION, "LGPL", GST_PACKAGE_NAME,
 498     GST_PACKAGE_ORIGIN);