gstdcaparse.c 18.9 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
/* GStreamer DCA parser
 * Copyright (C) 2010 Tim-Philipp Müller <tim centricular net>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the
Tim-Philipp Müller's avatar
Tim-Philipp Müller committed
16 17
 * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
 * Boston, MA 02110-1301, USA.
18 19 20 21 22 23 24 25
 */

/**
 * SECTION:element-dcaparse
 * @short_description: DCA (DTS Coherent Acoustics) parser
 * @see_also: #GstAmrParse, #GstAACParse, #GstAc3Parse
 *
 * This is a DCA (DTS Coherent Acoustics) parser.
26 27
 *
 * <refsect2>
28
 * <title>Example launch line</title>
29
 * |[
30
 * gst-launch-1.0 filesrc location=abc.dts ! dcaparse ! dtsdec ! audioresample ! audioconvert ! autoaudiosink
31
 * ]|
32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50
 * </refsect2>
 */

/* TODO:
 *  - should accept framed and unframed input (needs decodebin fixes first)
 *  - seeking in raw .dts files doesn't seem to work, but duration estimate ok
 *
 *  - if frames have 'odd' durations, the frame durations (plus timestamps)
 *    aren't adjusted up occasionally to make up for rounding error gaps.
 *    (e.g. if 512 samples per frame @ 48kHz = 10.666666667 ms/frame)
 */

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include <string.h>

#include "gstdcaparse.h"
51 52
#include <gst/base/base.h>
#include <gst/pbutils/pbutils.h>
53 54 55 56 57 58 59

GST_DEBUG_CATEGORY_STATIC (dca_parse_debug);
#define GST_CAT_DEFAULT dca_parse_debug

static GstStaticPadTemplate src_template = GST_STATIC_PAD_TEMPLATE ("src",
    GST_PAD_SRC,
    GST_PAD_ALWAYS,
60 61 62 63 64
    GST_STATIC_CAPS ("audio/x-dts,"
        " framed = (boolean) true,"
        " channels = (int) [ 1, 8 ],"
        " rate = (int) [ 8000, 192000 ],"
        " depth = (int) { 14, 16 },"
65 66
        " endianness = (int) { LITTLE_ENDIAN, BIG_ENDIAN }, "
        " block-size = (int) [ 1, MAX], " " frame-size = (int) [ 1, MAX]"));
67 68 69 70

static GstStaticPadTemplate sink_template = GST_STATIC_PAD_TEMPLATE ("sink",
    GST_PAD_SINK,
    GST_PAD_ALWAYS,
71
    GST_STATIC_CAPS ("audio/x-dts; " "audio/x-private1-dts"));
72 73 74 75 76

static void gst_dca_parse_finalize (GObject * object);

static gboolean gst_dca_parse_start (GstBaseParse * parse);
static gboolean gst_dca_parse_stop (GstBaseParse * parse);
77 78
static GstFlowReturn gst_dca_parse_handle_frame (GstBaseParse * parse,
    GstBaseParseFrame * frame, gint * skipsize);
79 80
static GstFlowReturn gst_dca_parse_pre_push_frame (GstBaseParse * parse,
    GstBaseParseFrame * frame);
81 82
static GstCaps *gst_dca_parse_get_sink_caps (GstBaseParse * parse,
    GstCaps * filter);
83 84
static gboolean gst_dca_parse_set_sink_caps (GstBaseParse * parse,
    GstCaps * caps);
85

86 87
#define gst_dca_parse_parent_class parent_class
G_DEFINE_TYPE (GstDcaParse, gst_dca_parse, GST_TYPE_BASE_PARSE);
88 89 90 91 92

static void
gst_dca_parse_class_init (GstDcaParseClass * klass)
{
  GstBaseParseClass *parse_class = GST_BASE_PARSE_CLASS (klass);
93
  GstElementClass *element_class = GST_ELEMENT_CLASS (klass);
94 95 96 97 98 99 100 101 102
  GObjectClass *object_class = G_OBJECT_CLASS (klass);

  GST_DEBUG_CATEGORY_INIT (dca_parse_debug, "dcaparse", 0,
      "DCA audio stream parser");

  object_class->finalize = gst_dca_parse_finalize;

  parse_class->start = GST_DEBUG_FUNCPTR (gst_dca_parse_start);
  parse_class->stop = GST_DEBUG_FUNCPTR (gst_dca_parse_stop);
103
  parse_class->handle_frame = GST_DEBUG_FUNCPTR (gst_dca_parse_handle_frame);
104 105
  parse_class->pre_push_frame =
      GST_DEBUG_FUNCPTR (gst_dca_parse_pre_push_frame);
106
  parse_class->get_sink_caps = GST_DEBUG_FUNCPTR (gst_dca_parse_get_sink_caps);
107
  parse_class->set_sink_caps = GST_DEBUG_FUNCPTR (gst_dca_parse_set_sink_caps);
108

109 110
  gst_element_class_add_static_pad_template (element_class, &sink_template);
  gst_element_class_add_static_pad_template (element_class, &src_template);
111

112
  gst_element_class_set_static_metadata (element_class,
113 114
      "DTS Coherent Acoustics audio stream parser", "Codec/Parser/Audio",
      "DCA parser", "Tim-Philipp Müller <tim centricular net>");
115 116 117 118 119 120 121
}

static void
gst_dca_parse_reset (GstDcaParse * dcaparse)
{
  dcaparse->channels = -1;
  dcaparse->rate = -1;
122 123
  dcaparse->depth = -1;
  dcaparse->endianness = -1;
124
  dcaparse->block_size = -1;
125
  dcaparse->frame_size = -1;
126
  dcaparse->last_sync = 0;
127
  dcaparse->sent_codec_tag = FALSE;
128 129 130
}

static void
131
gst_dca_parse_init (GstDcaParse * dcaparse)
132 133 134 135
{
  gst_base_parse_set_min_frame_size (GST_BASE_PARSE (dcaparse),
      DCA_MIN_FRAMESIZE);
  gst_dca_parse_reset (dcaparse);
136 137
  dcaparse->baseparse_chainfunc =
      GST_BASE_PARSE_SINK_PAD (GST_BASE_PARSE (dcaparse))->chainfunc;
138 139

  GST_PAD_SET_ACCEPT_INTERSECT (GST_BASE_PARSE_SINK_PAD (dcaparse));
140
  GST_PAD_SET_ACCEPT_TEMPLATE (GST_BASE_PARSE_SINK_PAD (dcaparse));
141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171
}

static void
gst_dca_parse_finalize (GObject * object)
{
  G_OBJECT_CLASS (parent_class)->finalize (object);
}

static gboolean
gst_dca_parse_start (GstBaseParse * parse)
{
  GstDcaParse *dcaparse = GST_DCA_PARSE (parse);

  GST_DEBUG_OBJECT (parse, "starting");

  gst_dca_parse_reset (dcaparse);

  return TRUE;
}

static gboolean
gst_dca_parse_stop (GstBaseParse * parse)
{
  GST_DEBUG_OBJECT (parse, "stopping");

  return TRUE;
}

static gboolean
gst_dca_parse_parse_header (GstDcaParse * dcaparse,
    const GstByteReader * reader, guint * frame_size,
172
    guint * sample_rate, guint * channels, guint * depth,
173 174
    gint * endianness, guint * num_blocks, guint * samples_per_block,
    gboolean * terminator)
175 176 177 178 179 180 181 182 183 184
{
  static const int sample_rates[16] = { 0, 8000, 16000, 32000, 0, 0, 11025,
    22050, 44100, 0, 0, 12000, 24000, 48000, 96000, 192000
  };
  static const guint8 channels_table[16] = { 1, 2, 2, 2, 2, 3, 3, 4, 4, 5,
    6, 6, 6, 7, 8, 8
  };
  GstByteReader r = *reader;
  guint16 hdr[8];
  guint32 marker;
185
  guint chans, lfe, i;
186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226

  if (gst_byte_reader_get_remaining (&r) < (4 + sizeof (hdr)))
    return FALSE;

  marker = gst_byte_reader_peek_uint32_be_unchecked (&r);

  /* raw big endian or 14-bit big endian */
  if (marker == 0x7FFE8001 || marker == 0x1FFFE800) {
    for (i = 0; i < G_N_ELEMENTS (hdr); ++i)
      hdr[i] = gst_byte_reader_get_uint16_be_unchecked (&r);
  } else
    /* raw little endian or 14-bit little endian */
  if (marker == 0xFE7F0180 || marker == 0xFF1F00E8) {
    for (i = 0; i < G_N_ELEMENTS (hdr); ++i)
      hdr[i] = gst_byte_reader_get_uint16_le_unchecked (&r);
  } else {
    return FALSE;
  }

  GST_LOG_OBJECT (dcaparse, "dts sync marker 0x%08x at offset %u", marker,
      gst_byte_reader_get_pos (reader));

  /* 14-bit mode */
  if (marker == 0x1FFFE800 || marker == 0xFF1F00E8) {
    if ((hdr[2] & 0xFFF0) != 0x07F0)
      return FALSE;
    /* discard top 2 bits (2 void), shift in 2 */
    hdr[0] = (hdr[0] << 2) | ((hdr[1] >> 12) & 0x0003);
    /* discard top 4 bits (2 void, 2 shifted into hdr[0]), shift in 4 etc. */
    hdr[1] = (hdr[1] << 4) | ((hdr[2] >> 10) & 0x000F);
    hdr[2] = (hdr[2] << 6) | ((hdr[3] >> 8) & 0x003F);
    hdr[3] = (hdr[3] << 8) | ((hdr[4] >> 6) & 0x00FF);
    hdr[4] = (hdr[4] << 10) | ((hdr[5] >> 4) & 0x03FF);
    hdr[5] = (hdr[5] << 12) | ((hdr[6] >> 2) & 0x0FFF);
    hdr[6] = (hdr[6] << 14) | ((hdr[7] >> 0) & 0x3FFF);
    g_assert (hdr[0] == 0x7FFE && hdr[1] == 0x8001);
  }

  GST_LOG_OBJECT (dcaparse, "frame header: %04x%04x%04x%04x",
      hdr[2], hdr[3], hdr[4], hdr[5]);

227 228 229
  *terminator = (hdr[2] & 0x80) ? FALSE : TRUE;
  *samples_per_block = ((hdr[2] >> 10) & 0x1f) + 1;
  *num_blocks = ((hdr[2] >> 2) & 0x7F) + 1;
230 231 232 233 234 235
  *frame_size = (((hdr[2] & 0x03) << 12) | (hdr[3] >> 4)) + 1;
  chans = ((hdr[3] & 0x0F) << 2) | (hdr[4] >> 14);
  *sample_rate = sample_rates[(hdr[4] >> 10) & 0x0F];
  lfe = (hdr[5] >> 9) & 0x03;

  GST_TRACE_OBJECT (dcaparse, "frame size %u, num_blocks %u, rate %u, "
236 237
      "samples per block %u", *frame_size, *num_blocks, *sample_rate,
      *samples_per_block);
238

239
  if (*num_blocks < 6 || *frame_size < 96 || *sample_rate == 0)
240 241 242 243 244 245 246 247 248 249
    return FALSE;

  if (marker == 0x1FFFE800 || marker == 0xFF1F00E8)
    *frame_size = (*frame_size * 16) / 14;      /* FIXME: round up? */

  if (chans < G_N_ELEMENTS (channels_table))
    *channels = channels_table[chans] + ((lfe) ? 1 : 0);
  else
    *channels = 0;

250 251 252 253 254 255
  if (depth)
    *depth = (marker == 0x1FFFE800 || marker == 0xFF1F00E8) ? 14 : 16;
  if (endianness)
    *endianness = (marker == 0xFE7F0180 || marker == 0xFF1F00E8) ?
        G_LITTLE_ENDIAN : G_BIG_ENDIAN;

256 257 258
  GST_TRACE_OBJECT (dcaparse, "frame size %u, channels %u, rate %u, "
      "num_blocks %u, samples_per_block %u", *frame_size, *channels,
      *sample_rate, *num_blocks, *samples_per_block);
259 260 261 262 263 264

  return TRUE;
}

static gint
gst_dca_parse_find_sync (GstDcaParse * dcaparse, GstByteReader * reader,
265
    gsize bufsize, guint32 * sync)
266
{
267
  guint32 best_sync = 0;
268 269 270 271 272
  guint best_offset = G_MAXUINT;
  gint off;

  /* FIXME: verify syncs via _parse_header() here already */

273
  /* Raw little endian */
274
  off = gst_byte_reader_masked_scan_uint32 (reader, 0xffffffff, 0xfe7f0180,
275
      0, bufsize);
276 277 278 279 280
  if (off >= 0 && off < best_offset) {
    best_offset = off;
    best_sync = 0xfe7f0180;
  }

281
  /* Raw big endian */
282
  off = gst_byte_reader_masked_scan_uint32 (reader, 0xffffffff, 0x7ffe8001,
283
      0, bufsize);
284 285 286 287 288 289 290 291
  if (off >= 0 && off < best_offset) {
    best_offset = off;
    best_sync = 0x7ffe8001;
  }

  /* FIXME: check next 2 bytes as well for 14-bit formats (but then don't
   * forget to adjust the *skipsize= in _check_valid_frame() */

292 293
  /* 14-bit little endian  */
  off = gst_byte_reader_masked_scan_uint32 (reader, 0xffffffff, 0xff1f00e8,
294
      0, bufsize);
295 296
  if (off >= 0 && off < best_offset) {
    best_offset = off;
297
    best_sync = 0xff1f00e8;
298 299
  }

300
  /* 14-bit big endian  */
301
  off = gst_byte_reader_masked_scan_uint32 (reader, 0xffffffff, 0x1fffe800,
302
      0, bufsize);
303 304 305 306 307 308 309 310 311 312 313 314
  if (off >= 0 && off < best_offset) {
    best_offset = off;
    best_sync = 0x1fffe800;
  }

  if (best_offset == G_MAXUINT)
    return -1;

  *sync = best_sync;
  return best_offset;
}

315 316 317
static GstFlowReturn
gst_dca_parse_handle_frame (GstBaseParse * parse,
    GstBaseParseFrame * frame, gint * skipsize)
318 319
{
  GstDcaParse *dcaparse = GST_DCA_PARSE (parse);
320
  GstBuffer *buf = frame->buffer;
321
  GstByteReader r;
322
  gboolean parser_in_sync;
323
  gboolean terminator;
324
  guint32 sync = 0;
325
  guint size = 0, rate, chans, num_blocks, samples_per_block, depth;
326 327
  gint block_size;
  gint endianness;
328
  gint off = -1;
Wim Taymans's avatar
Wim Taymans committed
329
  GstMapInfo map;
330
  GstFlowReturn ret = GST_FLOW_EOS;
331
  gsize extra_size = 0;
332

Wim Taymans's avatar
Wim Taymans committed
333
  gst_buffer_map (buf, &map, GST_MAP_READ);
334

335 336
  if (G_UNLIKELY (map.size < 16)) {
    *skipsize = 1;
337
    goto cleanup;
338
  }
339

340
  parser_in_sync = !GST_BASE_PARSE_LOST_SYNC (parse);
341

Wim Taymans's avatar
Wim Taymans committed
342
  gst_byte_reader_init (&r, map.data, map.size);
343

344 345
  if (G_LIKELY (parser_in_sync && dcaparse->last_sync != 0)) {
    off = gst_byte_reader_masked_scan_uint32 (&r, 0xffffffff,
Wim Taymans's avatar
Wim Taymans committed
346
        dcaparse->last_sync, 0, map.size);
347 348 349
  }

  if (G_UNLIKELY (off < 0)) {
Wim Taymans's avatar
Wim Taymans committed
350
    off = gst_dca_parse_find_sync (dcaparse, &r, map.size, &sync);
351 352 353 354
  }

  /* didn't find anything that looks like a sync word, skip */
  if (off < 0) {
Wim Taymans's avatar
Wim Taymans committed
355
    *skipsize = map.size - 3;
356
    GST_DEBUG_OBJECT (dcaparse, "no sync, skipping %d bytes", *skipsize);
357
    goto cleanup;
358 359 360 361 362 363 364
  }

  GST_LOG_OBJECT (parse, "possible sync %08x at buffer offset %d", sync, off);

  /* possible frame header, but not at offset 0? skip bytes before sync */
  if (off > 0) {
    *skipsize = off;
365
    goto cleanup;
366 367 368
  }

  /* make sure the values in the frame header look sane */
369 370
  if (!gst_dca_parse_parse_header (dcaparse, &r, &size, &rate, &chans, &depth,
          &endianness, &num_blocks, &samples_per_block, &terminator)) {
371
    *skipsize = 4;
372
    goto cleanup;
373 374 375 376 377 378 379
  }

  GST_LOG_OBJECT (parse, "got frame, sync %08x, size %u, rate %d, channels %d",
      sync, size, rate, chans);

  dcaparse->last_sync = sync;

380 381 382 383 384 385
  /* FIXME: Don't look for a second syncword, there are streams out there
   * that consistently contain garbage between every frame so we never ever
   * find a second consecutive syncword.
   * See https://bugzilla.gnome.org/show_bug.cgi?id=738237
   */
#if 0
386
  parser_draining = GST_BASE_PARSE_DRAINING (parse);
387 388 389 390

  if (!parser_in_sync && !parser_draining) {
    /* check for second frame to be sure */
    GST_DEBUG_OBJECT (dcaparse, "resyncing; checking next frame syncword");
Wim Taymans's avatar
Wim Taymans committed
391
    if (map.size >= (size + 16)) {
392 393
      guint s2, r2, c2, n2, s3;
      gboolean t;
394

Wim Taymans's avatar
Wim Taymans committed
395 396
      GST_MEMDUMP ("buf", map.data, size + 16);
      gst_byte_reader_init (&r, map.data, map.size);
397 398
      gst_byte_reader_skip_unchecked (&r, size);

399
      if (!gst_dca_parse_parse_header (dcaparse, &r, &s2, &r2, &c2, NULL, NULL,
400
              &n2, &s3, &t)) {
401 402
        GST_DEBUG_OBJECT (dcaparse, "didn't find second syncword");
        *skipsize = 4;
403
        goto cleanup;
404 405 406 407 408
      }

      /* ok, got sync now, let's assume constant frame size */
      gst_base_parse_set_min_frame_size (parse, size);
    } else {
409
      /* wait for some more data */
410
      GST_LOG_OBJECT (dcaparse,
Wim Taymans's avatar
Wim Taymans committed
411
          "next sync out of reach (%" G_GSIZE_FORMAT " < %u)", map.size,
412
          size + 16);
413
      goto cleanup;
414 415
    }
  }
416
#endif
417

418 419
  /* found frame */
  ret = GST_FLOW_OK;
420

421
  /* metadata handling */
422 423
  block_size = num_blocks * samples_per_block;

424
  if (G_UNLIKELY (dcaparse->rate != rate || dcaparse->channels != chans
425
          || dcaparse->depth != depth || dcaparse->endianness != endianness
426 427
          || (!terminator && dcaparse->block_size != block_size)
          || (size != dcaparse->frame_size))) {
428 429 430 431
    GstCaps *caps;

    caps = gst_caps_new_simple ("audio/x-dts",
        "framed", G_TYPE_BOOLEAN, TRUE,
432
        "rate", G_TYPE_INT, rate, "channels", G_TYPE_INT, chans,
433
        "endianness", G_TYPE_INT, endianness, "depth", G_TYPE_INT, depth,
434 435
        "block-size", G_TYPE_INT, block_size, "frame-size", G_TYPE_INT, size,
        NULL);
436 437 438 439 440
    gst_pad_set_caps (GST_BASE_PARSE_SRC_PAD (parse), caps);
    gst_caps_unref (caps);

    dcaparse->rate = rate;
    dcaparse->channels = chans;
441 442
    dcaparse->depth = depth;
    dcaparse->endianness = endianness;
443
    dcaparse->block_size = block_size;
444
    dcaparse->frame_size = size;
445

446
    gst_base_parse_set_frame_rate (parse, rate, block_size, 0, 0);
447 448
  }

449
cleanup:
450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472
  /* it is possible that DTS HD substream after DTS core */
  if (parse->flags & GST_BASE_PARSE_FLAG_DRAINING || map.size >= size + 9) {
    extra_size = 0;
    if (map.size >= size + 9) {
      const guint8 *next = map.data + size;
      /* Check for DTS_SYNCWORD_SUBSTREAM */
      if (next[0] == 0x64 && next[1] == 0x58 && next[2] == 0x20
          && next[3] == 0x25) {
        /* 7.4.1 Extension Substream Header */
        GstBitReader reader;
        gst_bit_reader_init (&reader, next + 4, 5);
        gst_bit_reader_skip (&reader, 8 + 2);   /* skip UserDefinedBits and nExtSSIndex) */
        if (gst_bit_reader_get_bits_uint8_unchecked (&reader, 1) == 0) {
          gst_bit_reader_skip (&reader, 8);
          extra_size =
              gst_bit_reader_get_bits_uint32_unchecked (&reader, 16) + 1;
        } else {
          gst_bit_reader_skip (&reader, 12);
          extra_size =
              gst_bit_reader_get_bits_uint32_unchecked (&reader, 20) + 1;
        }
      }
    }
473
    gst_buffer_unmap (buf, &map);
474 475 476 477 478
    if (ret == GST_FLOW_OK && size + extra_size <= map.size) {
      ret = gst_base_parse_finish_frame (parse, frame, size + extra_size);
    } else {
      ret = GST_FLOW_OK;
    }
479
  } else {
480
    gst_buffer_unmap (buf, &map);
481
  }
482 483

  return ret;
484
}
485

486 487 488 489 490 491 492 493 494
/*
 * MPEG-PS private1 streams add a 2 bytes "Audio Substream Headers" for each
 * buffer (not each frame) with the offset of the next frame's start.
 * These 2 bytes can be dropped safely as they do not include any timing
 * information, only the offset to the start of the next frame.
 * See gstac3parse.c for a more detailed description.
 * */

static GstFlowReturn
495
gst_dca_parse_chain_priv (GstPad * pad, GstObject * parent, GstBuffer * buffer)
496 497
{
  GstDcaParse *dcaparse = GST_DCA_PARSE (parent);
498 499 500 501 502 503 504 505 506 507 508 509 510
  GstFlowReturn ret;
  GstBuffer *newbuf;
  gsize size;

  size = gst_buffer_get_size (buffer);
  if (size >= 2) {
    newbuf = gst_buffer_copy_region (buffer, GST_BUFFER_COPY_ALL, 2, size - 2);
    gst_buffer_unref (buffer);
    ret = dcaparse->baseparse_chainfunc (pad, parent, newbuf);
  } else {
    gst_buffer_unref (buffer);
    ret = GST_FLOW_OK;
  }
511 512 513 514

  return ret;
}

515 516 517 518 519 520 521 522 523 524 525 526 527
static void
remove_fields (GstCaps * caps)
{
  guint i, n;

  n = gst_caps_get_size (caps);
  for (i = 0; i < n; i++) {
    GstStructure *s = gst_caps_get_structure (caps, i);

    gst_structure_remove_field (s, "framed");
  }
}

528
static GstCaps *
529
gst_dca_parse_get_sink_caps (GstBaseParse * parse, GstCaps * filter)
530
{
Wim Taymans's avatar
Wim Taymans committed
531
  GstCaps *peercaps, *templ;
532 533
  GstCaps *res;

534
  templ = gst_pad_get_pad_template_caps (GST_BASE_PARSE_SINK_PAD (parse));
535 536 537 538 539 540 541 542
  if (filter) {
    GstCaps *fcopy = gst_caps_copy (filter);
    /* Remove the fields we convert */
    remove_fields (fcopy);
    peercaps = gst_pad_peer_query_caps (GST_BASE_PARSE_SRC_PAD (parse), fcopy);
    gst_caps_unref (fcopy);
  } else
    peercaps = gst_pad_peer_query_caps (GST_BASE_PARSE_SRC_PAD (parse), NULL);
543

544 545 546
  if (peercaps) {
    /* Remove the framed field */
    peercaps = gst_caps_make_writable (peercaps);
547
    remove_fields (peercaps);
548

Wim Taymans's avatar
Wim Taymans committed
549
    res = gst_caps_intersect_full (peercaps, templ, GST_CAPS_INTERSECT_FIRST);
550
    gst_caps_unref (peercaps);
551
    gst_caps_unref (templ);
552
  } else {
Wim Taymans's avatar
Wim Taymans committed
553
    res = templ;
554 555
  }

556 557 558 559 560 561 562 563 564
  if (filter) {
    GstCaps *intersection;

    intersection =
        gst_caps_intersect_full (filter, res, GST_CAPS_INTERSECT_FIRST);
    gst_caps_unref (res);
    res = intersection;
  }

565 566
  return res;
}
567 568 569 570 571 572 573 574 575 576 577 578 579 580 581

static gboolean
gst_dca_parse_set_sink_caps (GstBaseParse * parse, GstCaps * caps)
{
  GstStructure *s;
  GstDcaParse *dcaparse = GST_DCA_PARSE (parse);

  s = gst_caps_get_structure (caps, 0);
  if (gst_structure_has_name (s, "audio/x-private1-dts")) {
    gst_pad_set_chain_function (parse->sinkpad, gst_dca_parse_chain_priv);
  } else {
    gst_pad_set_chain_function (parse->sinkpad, dcaparse->baseparse_chainfunc);
  }
  return TRUE;
}
582 583 584 585 586 587 588 589 590 591 592 593

static GstFlowReturn
gst_dca_parse_pre_push_frame (GstBaseParse * parse, GstBaseParseFrame * frame)
{
  GstDcaParse *dcaparse = GST_DCA_PARSE (parse);

  if (!dcaparse->sent_codec_tag) {
    GstTagList *taglist;
    GstCaps *caps;

    /* codec tag */
    caps = gst_pad_get_current_caps (GST_BASE_PARSE_SRC_PAD (parse));
594 595 596 597 598 599 600 601 602 603 604
    if (G_UNLIKELY (caps == NULL)) {
      if (GST_PAD_IS_FLUSHING (GST_BASE_PARSE_SRC_PAD (parse))) {
        GST_INFO_OBJECT (parse, "Src pad is flushing");
        return GST_FLOW_FLUSHING;
      } else {
        GST_INFO_OBJECT (parse, "Src pad is not negotiated!");
        return GST_FLOW_NOT_NEGOTIATED;
      }
    }

    taglist = gst_tag_list_new_empty ();
605 606 607 608
    gst_pb_utils_add_codec_description_to_tag_list (taglist,
        GST_TAG_AUDIO_CODEC, caps);
    gst_caps_unref (caps);

609 610
    gst_base_parse_merge_tags (parse, taglist, GST_TAG_MERGE_REPLACE);
    gst_tag_list_unref (taglist);
611 612 613 614 615 616 617

    /* also signals the end of first-frame processing */
    dcaparse->sent_codec_tag = TRUE;
  }

  return GST_FLOW_OK;
}