subprojects/gst-plugins-bad/ext/fdkaac/gstfdkaacdec.c

   1 /*
   2  * Copyright (C) 2016 Sebastian Dröge <sebastian@centricular.com>
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Library General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
  17  * Boston, MA 02110-1301, USA.
  18  */
  19
  20 #ifdef HAVE_CONFIG_H
  21 #include "config.h"
  22 #endif
  23
  24 #include "gstfdkaac.h"
  25 #include "gstfdkaacdec.h"
  26
  27 #include <gst/pbutils/pbutils.h>
  28
  29 #include <string.h>
  30
  31 /* TODO:
  32  * - LOAS / LATM support
  33  * - Error concealment
  34  */
  35
  36 #ifndef HAVE_FDK_AAC_0_1_4
  37 #define AAC_PCM_MAX_OUTPUT_CHANNELS AAC_PCM_OUTPUT_CHANNELS
  38 #define CHANNELS_CAPS_STR "channels = (int) [1, 6]"
  39 #else
  40 #define CHANNELS_CAPS_STR "channels = (int) [1, 8]"
  41 #endif
  42
  43 static GstStaticPadTemplate sink_template = GST_STATIC_PAD_TEMPLATE ("sink",
  44     GST_PAD_SINK,
  45     GST_PAD_ALWAYS,
  46     GST_STATIC_CAPS ("audio/mpeg, "
  47         "mpegversion = (int) {2, 4}, "
  48         "stream-format = (string) { adts, adif, raw }, " CHANNELS_CAPS_STR)
  49     );
  50
  51 static GstStaticPadTemplate src_template = GST_STATIC_PAD_TEMPLATE ("src",
  52     GST_PAD_SRC,
  53     GST_PAD_ALWAYS,
  54     GST_STATIC_CAPS ("audio/x-raw, "
  55         "format = (string) " GST_AUDIO_NE (S16) ", "
  56         "layout = (string) interleaved, "
  57         "rate = (int) [8000, 96000], " CHANNELS_CAPS_STR)
  58     );
  59
  60 GST_DEBUG_CATEGORY_STATIC (gst_fdkaacdec_debug);
  61 #define GST_CAT_DEFAULT gst_fdkaacdec_debug
  62
  63 static gboolean gst_fdkaacdec_start (GstAudioDecoder * dec);
  64 static gboolean gst_fdkaacdec_stop (GstAudioDecoder * dec);
  65 static gboolean gst_fdkaacdec_set_format (GstAudioDecoder * dec,
  66     GstCaps * caps);
  67 static GstFlowReturn gst_fdkaacdec_handle_frame (GstAudioDecoder * dec,
  68     GstBuffer * in_buf);
  69 static void gst_fdkaacdec_flush (GstAudioDecoder * dec, gboolean hard);
  70
  71 G_DEFINE_TYPE (GstFdkAacDec, gst_fdkaacdec, GST_TYPE_AUDIO_DECODER);
  72 GST_ELEMENT_REGISTER_DEFINE (fdkaacdec, "fdkaacdec", GST_RANK_MARGINAL,
  73     GST_TYPE_FDKAACDEC);
  74
  75 static gboolean
  76 gst_fdkaacdec_start (GstAudioDecoder * dec)
  77 {
  78   GstFdkAacDec *self = GST_FDKAACDEC (dec);
  79
  80   GST_DEBUG_OBJECT (self, "start");
  81
  82   gst_audio_info_init (&self->info);
  83   self->sample_rate = 0;
  84
  85   return TRUE;
  86 }
  87
  88 static gboolean
  89 gst_fdkaacdec_stop (GstAudioDecoder * dec)
  90 {
  91   GstFdkAacDec *self = GST_FDKAACDEC (dec);
  92
  93   GST_DEBUG_OBJECT (self, "stop");
  94
  95   g_free (self->decode_buffer);
  96   self->decode_buffer = NULL;
  97
  98   if (self->dec)
  99     aacDecoder_Close (self->dec);
 100   self->dec = NULL;
 101
 102   return TRUE;
 103 }
 104
 105 static gboolean
 106 gst_fdkaacdec_set_format (GstAudioDecoder * dec, GstCaps * caps)
 107 {
 108   GstFdkAacDec *self = GST_FDKAACDEC (dec);
 109   TRANSPORT_TYPE transport_format;
 110   GstStructure *s;
 111   const gchar *stream_format;
 112   AAC_DECODER_ERROR err;
 113
 114   if (self->dec) {
 115     /* drain */
 116     gst_fdkaacdec_handle_frame (dec, NULL);
 117     aacDecoder_Close (self->dec);
 118     self->dec = NULL;
 119   }
 120
 121   s = gst_caps_get_structure (caps, 0);
 122   stream_format = gst_structure_get_string (s, "stream-format");
 123   if (strcmp (stream_format, "raw") == 0) {
 124     transport_format = TT_MP4_RAW;
 125   } else if (strcmp (stream_format, "adif") == 0) {
 126     transport_format = TT_MP4_ADIF;
 127   } else if (strcmp (stream_format, "adts") == 0) {
 128     transport_format = TT_MP4_ADTS;
 129   } else {
 130     g_assert_not_reached ();
 131   }
 132
 133   self->dec = aacDecoder_Open (transport_format, 1);
 134   if (!self->dec) {
 135     GST_ERROR_OBJECT (self, "Failed to open decoder");
 136     return FALSE;
 137   }
 138
 139   if (transport_format == TT_MP4_RAW) {
 140     GstBuffer *codec_data = NULL;
 141     GstMapInfo map;
 142     guint8 *data;
 143     guint size;
 144
 145     gst_structure_get (s, "codec_data", GST_TYPE_BUFFER, &codec_data, NULL);
 146
 147     if (!codec_data) {
 148       GST_ERROR_OBJECT (self, "Raw AAC without codec_data not supported");
 149       return FALSE;
 150     }
 151
 152     gst_buffer_map (codec_data, &map, GST_MAP_READ);
 153     data = map.data;
 154     size = map.size;
 155
 156     if ((err = aacDecoder_ConfigRaw (self->dec, &data, &size)) != AAC_DEC_OK) {
 157       gst_buffer_unmap (codec_data, &map);
 158       gst_buffer_unref (codec_data);
 159       GST_ERROR_OBJECT (self, "Invalid codec_data: %d", err);
 160       return FALSE;
 161     }
 162
 163     gst_buffer_unmap (codec_data, &map);
 164     gst_buffer_unref (codec_data);
 165   }
 166
 167   err = aacDecoder_SetParam (self->dec, AAC_PCM_MAX_OUTPUT_CHANNELS, 0);
 168   if (err != AAC_DEC_OK) {
 169     GST_ERROR_OBJECT (self, "Failed to disable downmixing: %d", err);
 170     return FALSE;
 171   }
 172
 173   /* Choose WAV channel mapping to get interleaving even with libfdk-aac 2.0.0
 174    * The pChannelIndices retain the indices from the standard MPEG mapping so
 175    * we're agnostic to the actual order. */
 176   err = aacDecoder_SetParam (self->dec, AAC_PCM_OUTPUT_CHANNEL_MAPPING, 1);
 177   if (err != AAC_DEC_OK) {
 178     GST_ERROR_OBJECT (self, "Failed to set output channel mapping: %d", err);
 179     return FALSE;
 180   }
 181
 182   /* 64 channels * 2048 samples * 2 bytes per sample */
 183   if (!self->decode_buffer) {
 184     self->decode_buffer_size = 64 * 2048;
 185     self->decode_buffer = g_new (gint16, self->decode_buffer_size);
 186   }
 187
 188   return TRUE;
 189 }
 190
 191 static gboolean
 192 gst_fdkaacdec_map_channels (GstFdkAacDec * self, const CStreamInfo * in,
 193     gboolean * updated)
 194 {
 195   GstAudioChannelPosition *positions = self->positions;
 196   AUDIO_CHANNEL_TYPE *channel_types = in->pChannelType;
 197   UCHAR *channel_indices = in->pChannelIndices;
 198   INT i, channels = in->numChannels;
 199   guint64 mask_mapped = 0;
 200
 201 #define DEF_CHANSET(name, max) \
 202   GstAudioChannelPosition *set_ ## name[max] = {NULL}; \
 203   guint n_ ## name = 0, mapped_ ## name = 0
 204
 205 #define PUSH_CHAN(name, index, pos_index) G_STMT_START { \
 206     if ((index) >= G_N_ELEMENTS (set_ ## name)) { \
 207       GST_WARNING_OBJECT (self, "Too many %s channels (%d)", \
 208           #name, (gint) (index)); \
 209       goto error; \
 210     } else if (set_ ## name[index] != NULL) { \
 211       GST_WARNING_OBJECT (self, "Channel %s[%d] already mapped", \
 212           #name, (gint) (index)); \
 213       goto error; \
 214     } else { \
 215       GST_DEBUG_OBJECT (self, "Mapping channel %s[%d] to %d", \
 216           #name, (gint) (index), (gint) pos_index); \
 217       set_ ## name[index] = &positions[pos_index]; \
 218       n_ ## name = MAX (n_ ## name, (index) + 1); \
 219     } \
 220   } G_STMT_END
 221
 222 #define SHIFT_CHAN(name, pos) G_STMT_START { \
 223     if (mask_mapped & GST_AUDIO_CHANNEL_POSITION_MASK (pos)) { \
 224       GST_WARNING_OBJECT (self, "Position %s already mapped", #pos); \
 225       goto error; \
 226     } else if (set_ ## name[mapped_ ## name] == NULL) { \
 227       GST_WARNING_OBJECT (self, "Channel %s[%u] is a hole", \
 228           #name, mapped_ ## name); \
 229       goto error; \
 230     } else { \
 231       GST_DEBUG_OBJECT (self, "Mapping channel %s[%u] to %s", \
 232           #name, mapped_ ## name, #pos); \
 233       *set_ ## name[mapped_ ## name ++] = GST_AUDIO_CHANNEL_POSITION_ ## pos; \
 234       mask_mapped |= GST_AUDIO_CHANNEL_POSITION_MASK (pos); \
 235     } \
 236   } G_STMT_END
 237
 238   DEF_CHANSET (front, 7);
 239   DEF_CHANSET (side, 2);
 240   DEF_CHANSET (rear, 5);
 241   DEF_CHANSET (lfe, 2);
 242   DEF_CHANSET (top_front, 3);
 243   DEF_CHANSET (top_center, 3);
 244   DEF_CHANSET (top_rear, 3);
 245   DEF_CHANSET (bottom_front, 3);
 246
 247   if (self->channels == channels &&
 248       memcmp (self->channel_types, channel_types,
 249           channels * sizeof *channel_types) == 0 &&
 250       memcmp (self->channel_indices, channel_indices,
 251           channels * sizeof *channel_indices) == 0) {
 252     GST_TRACE_OBJECT (self, "Reusing cached positions for %d channels",
 253         channels);
 254     return TRUE;
 255   }
 256
 257   self->channels = channels;
 258   memcpy (self->channel_types, channel_types, channels * sizeof *channel_types);
 259   memcpy (self->channel_indices, channel_indices,
 260       channels * sizeof *channel_indices);
 261   *updated = TRUE;
 262
 263   for (i = 0; i < channels; i++) {
 264     guint8 type = in->pChannelType[i];
 265     guint8 index = in->pChannelIndices[i];
 266
 267     switch (type) {
 268       case ACT_FRONT:
 269         PUSH_CHAN (front, index, i);
 270         break;
 271       case ACT_SIDE:
 272         PUSH_CHAN (side, index, i);
 273         break;
 274       case ACT_BACK:
 275         PUSH_CHAN (rear, index, i);
 276         break;
 277       case ACT_LFE:
 278         PUSH_CHAN (lfe, index, i);
 279         break;
 280       case ACT_FRONT_TOP:
 281         PUSH_CHAN (top_front, index, i);
 282         break;
 283       case ACT_SIDE_TOP:
 284         PUSH_CHAN (top_center, index, i);
 285         break;
 286       case ACT_BACK_TOP:
 287         PUSH_CHAN (top_rear, index, i);
 288         break;
 289 #ifdef HAVE_FDK_AAC_0_1_4
 290       case ACT_FRONT_BOTTOM:
 291         PUSH_CHAN (bottom_front, index, i);
 292         break;
 293 #endif
 294       case ACT_NONE:
 295         GST_INFO_OBJECT (self, "Channel %d is unpositioned", i);
 296         goto error;
 297       default:
 298         GST_ERROR_OBJECT (self, "Channel %d has unknown type %d", i, type);
 299         goto error;
 300     }
 301   }
 302
 303   /* Outwards from the front center, following ISO/IEC 13818-7 8.5.2.2
 304    * "Explicit channel mapping using a program_config_element()" */
 305   switch (n_front) {
 306     case 7:
 307       SHIFT_CHAN (front, FRONT_CENTER);
 308     case 6:
 309       SHIFT_CHAN (front, FRONT_LEFT_OF_CENTER);
 310       SHIFT_CHAN (front, FRONT_RIGHT_OF_CENTER);
 311       SHIFT_CHAN (front, FRONT_LEFT);
 312       SHIFT_CHAN (front, FRONT_RIGHT);
 313       SHIFT_CHAN (front, WIDE_LEFT);
 314       SHIFT_CHAN (front, WIDE_RIGHT);
 315       break;
 316
 317     case 5:
 318       SHIFT_CHAN (front, FRONT_CENTER);
 319     case 4:
 320       SHIFT_CHAN (front, FRONT_LEFT_OF_CENTER);
 321       SHIFT_CHAN (front, FRONT_RIGHT_OF_CENTER);
 322       SHIFT_CHAN (front, WIDE_LEFT);
 323       SHIFT_CHAN (front, WIDE_RIGHT);
 324       break;
 325
 326     case 3:
 327       SHIFT_CHAN (front, FRONT_CENTER);
 328     case 2:
 329       SHIFT_CHAN (front, FRONT_LEFT);
 330       SHIFT_CHAN (front, FRONT_RIGHT);
 331       break;
 332
 333     case 1:
 334       SHIFT_CHAN (front, FRONT_CENTER);
 335       break;
 336   }
 337
 338   /* Front to rear */
 339   switch (n_side) {
 340     case 2:
 341       SHIFT_CHAN (side, SIDE_LEFT);
 342       SHIFT_CHAN (side, SIDE_RIGHT);
 343       break;
 344
 345     case 1:
 346       GST_ERROR_OBJECT (self, "Single side channel not supported");
 347       goto error;
 348   }
 349
 350   /* Inwards to the rear center */
 351   switch (n_rear) {
 352     case 5:
 353       SHIFT_CHAN (rear, SURROUND_LEFT);
 354       SHIFT_CHAN (rear, SURROUND_RIGHT);
 355       SHIFT_CHAN (rear, REAR_LEFT);
 356       SHIFT_CHAN (rear, REAR_RIGHT);
 357       SHIFT_CHAN (rear, REAR_CENTER);
 358       break;
 359
 360     case 4:
 361       SHIFT_CHAN (rear, SURROUND_LEFT);
 362       SHIFT_CHAN (rear, SURROUND_RIGHT);
 363       SHIFT_CHAN (rear, REAR_LEFT);
 364       SHIFT_CHAN (rear, REAR_RIGHT);
 365       break;
 366
 367     case 3:
 368       SHIFT_CHAN (rear, SURROUND_LEFT);
 369       SHIFT_CHAN (rear, SURROUND_RIGHT);
 370       SHIFT_CHAN (rear, REAR_CENTER);
 371       break;
 372
 373     case 2:
 374       SHIFT_CHAN (rear, SURROUND_LEFT);
 375       SHIFT_CHAN (rear, SURROUND_RIGHT);
 376       break;
 377
 378     case 1:
 379       SHIFT_CHAN (rear, REAR_CENTER);
 380       break;
 381   }
 382
 383   switch (n_lfe) {
 384     case 2:
 385       SHIFT_CHAN (lfe, LFE1);
 386       SHIFT_CHAN (lfe, LFE2);
 387       break;
 388
 389     case 1:
 390       SHIFT_CHAN (lfe, LFE1);
 391       break;
 392   }
 393
 394   switch (n_top_front) {
 395     case 3:
 396       SHIFT_CHAN (top_front, TOP_FRONT_CENTER);
 397     case 2:
 398       SHIFT_CHAN (top_front, TOP_FRONT_LEFT);
 399       SHIFT_CHAN (top_front, TOP_FRONT_RIGHT);
 400       break;
 401
 402     case 1:
 403       SHIFT_CHAN (top_front, TOP_FRONT_CENTER);
 404       break;
 405   }
 406
 407   switch (n_top_center) {
 408     case 3:
 409       SHIFT_CHAN (top_center, TOP_CENTER);
 410     case 2:
 411       SHIFT_CHAN (top_center, TOP_SIDE_LEFT);
 412       SHIFT_CHAN (top_center, TOP_SIDE_RIGHT);
 413       break;
 414
 415     case 1:
 416       SHIFT_CHAN (top_center, TOP_CENTER);
 417       break;
 418   }
 419
 420   switch (n_top_rear) {
 421     case 3:
 422       SHIFT_CHAN (top_rear, TOP_REAR_LEFT);
 423       SHIFT_CHAN (top_rear, TOP_REAR_RIGHT);
 424       SHIFT_CHAN (top_rear, TOP_REAR_CENTER);
 425       break;
 426
 427     case 2:
 428       SHIFT_CHAN (top_rear, TOP_REAR_LEFT);
 429       SHIFT_CHAN (top_rear, TOP_REAR_RIGHT);
 430       break;
 431
 432     case 1:
 433       SHIFT_CHAN (top_rear, TOP_REAR_CENTER);
 434       break;
 435   }
 436
 437   switch (n_bottom_front) {
 438     case 3:
 439       SHIFT_CHAN (bottom_front, BOTTOM_FRONT_CENTER);
 440     case 2:
 441       SHIFT_CHAN (bottom_front, BOTTOM_FRONT_LEFT);
 442       SHIFT_CHAN (bottom_front, BOTTOM_FRONT_RIGHT);
 443       break;
 444
 445     case 1:
 446       SHIFT_CHAN (bottom_front, BOTTOM_FRONT_CENTER);
 447       break;
 448   }
 449
 450   if (mask_mapped != 0) {
 451     GST_INFO_OBJECT (self, "Mapped %d front, %d side, %d rear, %d lfe,"
 452         " %d top front, %d top center, %d top rear, %d bottom front channels",
 453         mapped_front, mapped_side, mapped_rear, mapped_lfe, mapped_top_front,
 454         mapped_top_center, mapped_top_rear, mapped_bottom_front);
 455     return TRUE;
 456   }
 457
 458   if (channels == 1) {
 459     GST_INFO_OBJECT (self, "Mapped a mono channel");
 460     positions[0] = GST_AUDIO_CHANNEL_POSITION_MONO;
 461     return TRUE;
 462   }
 463
 464 error:
 465   if (channels > 0) {
 466     GST_WARNING_OBJECT (self, "Mapped %d channels, without positions",
 467         channels);
 468     for (i = 0; i < channels; i++)
 469       positions[i] = GST_AUDIO_CHANNEL_POSITION_NONE;
 470     return TRUE;
 471   }
 472
 473   GST_ERROR_OBJECT (self, "No channels to map");
 474   return FALSE;
 475
 476 #undef DEF_CHANSET
 477 #undef PUSH_CHAN
 478 #undef SHIFT_CHAN
 479 }
 480
 481 static gboolean
 482 gst_fdkaacdec_map_channel_config (GstFdkAacDec * self, const CStreamInfo * in,
 483     gboolean * updated)
 484 {
 485   const GstFdkAacChannelLayout *layout;
 486   CHANNEL_MODE config = in->channelConfig;
 487   INT channels = in->numChannels;
 488
 489   if (config == 0) {
 490     return gst_fdkaacdec_map_channels (self, in, updated);
 491   }
 492
 493   if (self->config == config && self->channels == channels) {
 494     GST_TRACE_OBJECT (self,
 495         "Reusing cached positions for channelConfig %d (%d channels)",
 496         config, channels);
 497     return TRUE;
 498   }
 499
 500   self->config = config;
 501   self->channels = channels;
 502   *updated = TRUE;
 503
 504   for (layout = channel_layouts; layout->channels; layout++) {
 505     if (layout->mode == config && layout->channels == channels)
 506       break;
 507   }
 508
 509   if (!layout->channels) {
 510     GST_WARNING_OBJECT (self, "Unknown channelConfig %d (%d channels)",
 511         config, channels);
 512     return gst_fdkaacdec_map_channels (self, in, updated);
 513   }
 514
 515   GST_INFO_OBJECT (self, "Known channelConfig %d (%d channels)",
 516       config, channels);
 517   memcpy (self->positions, layout->positions,
 518       channels * sizeof *self->positions);
 519
 520   return TRUE;
 521 }
 522
 523 static gboolean
 524 gst_fdkaacdec_update_info (GstFdkAacDec * self)
 525 {
 526   GstAudioChannelPosition positions[64];
 527   GstAudioInfo *info = &self->info;
 528   gint channels = self->channels;
 529
 530   memcpy (positions, self->positions, channels * sizeof *positions);
 531
 532   if (!gst_audio_channel_positions_to_valid_order (positions, channels)) {
 533     GST_ERROR_OBJECT (self, "Failed to reorder channels");
 534     return FALSE;
 535   }
 536
 537   gst_audio_info_set_format (info, GST_AUDIO_FORMAT_S16, self->sample_rate,
 538       channels, positions);
 539
 540   if (!gst_audio_decoder_set_output_format (GST_AUDIO_DECODER (self), info)) {
 541     GST_ERROR_OBJECT (self, "Failed to set output format");
 542     return FALSE;
 543   }
 544
 545   self->need_reorder = memcmp (positions, self->positions,
 546       channels * sizeof *positions) != 0;
 547   return TRUE;
 548 }
 549
 550 static GstFlowReturn
 551 gst_fdkaacdec_handle_frame (GstAudioDecoder * dec, GstBuffer * inbuf)
 552 {
 553   GstFdkAacDec *self = GST_FDKAACDEC (dec);
 554   GstFlowReturn ret = GST_FLOW_OK;
 555   GstBuffer *outbuf;
 556   GstMapInfo imap;
 557   AAC_DECODER_ERROR err;
 558   UINT flags = 0;
 559   guint size, valid;
 560   CStreamInfo *stream_info;
 561   gboolean updated = FALSE;
 562
 563   if (inbuf) {
 564     gst_buffer_ref (inbuf);
 565     gst_buffer_map (inbuf, &imap, GST_MAP_READ);
 566     valid = size = imap.size;
 567
 568     err = aacDecoder_Fill (self->dec, (guint8 **) & imap.data, &size, &valid);
 569     if (err != AAC_DEC_OK) {
 570       GST_AUDIO_DECODER_ERROR (self, 1, STREAM, DECODE, (NULL),
 571           ("filling error: %d", err), ret);
 572       goto out;
 573     }
 574
 575     if (GST_BUFFER_IS_DISCONT (inbuf)) {
 576       flags |= AACDEC_INTR;
 577     }
 578   } else {
 579     flags |= AACDEC_FLUSH;
 580   }
 581
 582   err = aacDecoder_DecodeFrame (self->dec, self->decode_buffer,
 583       self->decode_buffer_size, flags);
 584   if (err == AAC_DEC_TRANSPORT_SYNC_ERROR) {
 585     ret = GST_FLOW_OK;
 586     outbuf = NULL;
 587     goto finish;
 588   } else if ((err != AAC_DEC_OK) && (flags & AACDEC_FLUSH)) {
 589     /*
 590      * A flush/drain was requested when set_format got called. When a flush
 591      * gets requested, aacDecoder_DecodeFrame may not return AAC_DEC_OK. Do
 592      * not report a decoding error with GST_AUDIO_DECODER_ERROR for this case.
 593      */
 594     GST_LOG_OBJECT (self, "Decoder flush was requested");
 595     ret = GST_FLOW_OK;
 596     goto out;
 597   } else if (err != AAC_DEC_OK) {
 598     GST_AUDIO_DECODER_ERROR (self, 1, STREAM, DECODE, (NULL),
 599         ("decoding error: %d", err), ret);
 600     goto out;
 601   }
 602
 603   stream_info = aacDecoder_GetStreamInfo (self->dec);
 604   if (!stream_info) {
 605     GST_AUDIO_DECODER_ERROR (self, 1, STREAM, DECODE, (NULL),
 606         ("failed to get stream info"), ret);
 607     goto out;
 608   }
 609
 610   if (stream_info->sampleRate != self->sample_rate) {
 611     self->sample_rate = stream_info->sampleRate;
 612     updated = TRUE;
 613   }
 614
 615   if (!gst_fdkaacdec_map_channel_config (self, stream_info, &updated)) {
 616     ret = GST_FLOW_NOT_NEGOTIATED;
 617     goto out;
 618   }
 619
 620   if (updated && !gst_fdkaacdec_update_info (self)) {
 621     ret = GST_FLOW_NOT_NEGOTIATED;
 622     goto out;
 623   }
 624
 625   outbuf =
 626       gst_audio_decoder_allocate_output_buffer (dec,
 627       stream_info->frameSize * GST_AUDIO_INFO_BPF (&self->info));
 628
 629   gst_buffer_fill (outbuf, 0, self->decode_buffer,
 630       gst_buffer_get_size (outbuf));
 631
 632   if (self->need_reorder) {
 633     gst_audio_buffer_reorder_channels (outbuf,
 634         GST_AUDIO_INFO_FORMAT (&self->info),
 635         GST_AUDIO_INFO_CHANNELS (&self->info),
 636         self->positions, self->info.position);
 637   }
 638
 639 finish:
 640   ret = gst_audio_decoder_finish_frame (dec, outbuf, 1);
 641
 642 out:
 643
 644   if (inbuf) {
 645     gst_buffer_unmap (inbuf, &imap);
 646     gst_buffer_unref (inbuf);
 647   }
 648
 649   return ret;
 650 }
 651
 652 static void
 653 gst_fdkaacdec_flush (GstAudioDecoder * dec, gboolean hard)
 654 {
 655   GstFdkAacDec *self = GST_FDKAACDEC (dec);
 656
 657   if (self->dec) {
 658     AAC_DECODER_ERROR err;
 659     err = aacDecoder_DecodeFrame (self->dec, self->decode_buffer,
 660         self->decode_buffer_size, AACDEC_FLUSH);
 661     if (err != AAC_DEC_OK) {
 662       GST_ERROR_OBJECT (self, "flushing error: %d", err);
 663     }
 664   }
 665 }
 666
 667 static void
 668 gst_fdkaacdec_init (GstFdkAacDec * self)
 669 {
 670   self->dec = NULL;
 671
 672   gst_audio_decoder_set_drainable (GST_AUDIO_DECODER (self), TRUE);
 673   gst_audio_decoder_set_needs_format (GST_AUDIO_DECODER (self), TRUE);
 674 }
 675
 676 static void
 677 gst_fdkaacdec_class_init (GstFdkAacDecClass * klass)
 678 {
 679   GstElementClass *element_class = GST_ELEMENT_CLASS (klass);
 680   GstAudioDecoderClass *base_class = GST_AUDIO_DECODER_CLASS (klass);
 681
 682   base_class->start = GST_DEBUG_FUNCPTR (gst_fdkaacdec_start);
 683   base_class->stop = GST_DEBUG_FUNCPTR (gst_fdkaacdec_stop);
 684   base_class->set_format = GST_DEBUG_FUNCPTR (gst_fdkaacdec_set_format);
 685   base_class->handle_frame = GST_DEBUG_FUNCPTR (gst_fdkaacdec_handle_frame);
 686   base_class->flush = GST_DEBUG_FUNCPTR (gst_fdkaacdec_flush);
 687
 688   gst_element_class_add_static_pad_template (element_class, &sink_template);
 689   gst_element_class_add_static_pad_template (element_class, &src_template);
 690
 691   gst_element_class_set_static_metadata (element_class, "FDK AAC audio decoder",
 692       "Codec/Decoder/Audio", "FDK AAC audio decoder",
 693       "Sebastian Dröge <sebastian@centricular.com>");
 694
 695   GST_DEBUG_CATEGORY_INIT (gst_fdkaacdec_debug, "fdkaacdec", 0,
 696       "fdkaac decoder");
 697 }