plugins/avb/gstavbpcmsink.c

/*
 * Copyright (c) 2014, Freescale Semiconductor, Inc. All rights reserved.
 *
 * 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
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 */
#include <gst/tag/tag.h>
#include <gst/audio/audio.h>
#include "gstavbpcmsink.h"
#include "cip.h"


typedef struct{
  guint32 rate;
  guint8 syt_internal;
}SFC_STRUCT;
static SFC_STRUCT SFC_TABLE[] ={
  {32000,8},//0
  {44100,8},//1
  {48000,8},//2
  {88200,16},//3
  {96000,16},//4
  {176400,32},//5
  {192000,32}//6
};

#define DEFAULT_PACKET_COUNT 128
#define MAX_PACKET_LEN (1024)

GST_DEBUG_CATEGORY_STATIC (avb_pcm_sink_debug);
#define GST_CAT_DEFAULT avb_pcm_sink_debug

#define gst_avb_pcm_sink_parent_class parent_class
G_DEFINE_TYPE (GstAvbPcmSink, gst_avb_pcm_sink, GST_TYPE_AVBSINK);

#define PCM_AUDIO_CAPS \
  "audio/x-raw, "\
  "format = (string){S16LE, S24LE}, "\
  "rate = (int){32000, 44100, 48000, 88200, 96000, 176400, 192000}, "\
  "channels = (int)[1, 8]"

static GstStaticPadTemplate sink_template =
  GST_STATIC_PAD_TEMPLATE ("sink",
  GST_PAD_SINK,
  GST_PAD_ALWAYS,
  GST_STATIC_CAPS (PCM_AUDIO_CAPS));

static gstsutils_property avbsink_property[]=
{
  {"latency", G_TYPE_UINT, gst_avbsink_set_latency},
  {"use_ptp_time", G_TYPE_BOOLEAN, gst_avbsink_set_use_ptp_time},
  {"package_count",G_TYPE_UINT, gst_avbsink_set_package_count}
};
static gstsutils_property basesink_property[]=
{
    {"sync", G_TYPE_BOOLEAN, gst_base_sink_set_sync}
};

static gboolean
gst_avb_pcm_sink_parse_audio_info(GstAvbPcmSink * sink,GstAudioInfo * info)
{
  int i = 0;
  if(sink == NULL || info == NULL)
    return FALSE;

  sink->width = GST_AUDIO_INFO_WIDTH (info);
  sink->channels = GST_AUDIO_INFO_CHANNELS (info);
  sink->rate = GST_AUDIO_INFO_RATE (info);
  if(sink->width == 16){
    sink->label = 0x42;
  }else if(sink->width == 24){
    sink->label = 0x40;
  }else{
    GST_ERROR_OBJECT (sink,"process_buffer width is wrong");
    return FALSE;
  }

  for(i = 0; i < sizeof(SFC_TABLE)/sizeof(SFC_STRUCT); i++){
    if(sink->rate == SFC_TABLE[i].rate){
      sink->sfc = i;
      sink->syt_internal = SFC_TABLE[i].syt_internal;
      sink->dbs = sink->channels;
      return TRUE;
    }
  }

  return FALSE;
}
static guint8 gst_avb_pcm_sink_get_dbs(GstAvbSink * sink)
{
  GstAvbPcmSink *pcmsink;
  pcmsink = GST_AVB_PCM_SINK(sink);
  return pcmsink->dbs;
}
static guint8 gst_avb_pcm_sink_get_fn(GstAvbSink * sink){
  return 0;
}
static guint8 gst_avb_pcm_sink_get_sph(GstAvbSink * sink){
  return 0;
}
static guint8 gst_avb_pcm_sink_get_dbc(GstAvbSink * sink,guint32 payloadLen)
{
  GstAvbPcmSink *pcmsink;
  pcmsink = GST_AVB_PCM_SINK(sink);
  return (guint8)(payloadLen/pcmsink->dbs/sizeof(uint32));
}
static guint8 gst_avb_pcm_sink_get_fmt(GstAvbSink * sink)
{
  return CIP_FMT_AUDIO;
}
static guint8 gst_avb_pcm_sink_get_fdf(GstAvbSink * sink)
{
  GstAvbPcmSink *pcmsink;
  pcmsink = GST_AVB_PCM_SINK(sink);
  return pcmsink->sfc;
}
static guint16 gst_avb_pcm_sink_get_syt(GstAvbSink * sink)
{
  return 0xFFFF;
}
static guint32 gst_avb_pcm_sink_get_packet_len(GstAvbSink * sink,guint32 leftsize)
{
  GstAvbPcmSink *pcmsink;
  guint32 len = 0;
  guint32 count=0;
  guint32 max_count = 0;

  pcmsink = GST_AVB_PCM_SINK(sink);

  len = pcmsink->channels * pcmsink ->syt_internal * sizeof(uint32);
  max_count = gst_avbsink_get_package_count(sink);

  if(pcmsink->width == 16){
    leftsize = leftsize *2;
  }else{
    leftsize = leftsize * 4/3;
  }

  if(leftsize > MAX_PACKET_LEN)
    leftsize = MAX_PACKET_LEN;

  count = leftsize/len;

  if(count == 0)
    count = 1;

  if(count > max_count)
    count = max_count;

  return len * count;
}
static gboolean
gst_avb_pcm_sink_set_caps (GstBaseSink * basesink, GstCaps * caps)
{
  gboolean ret;
  GstAvbPcmSink *sink;
  const gchar *mimetype;
  GstStructure *structure;

  sink = GST_AVB_PCM_SINK (basesink);
  GST_DEBUG_OBJECT (sink,"gst_avb_pcm_sink_set_caps %"GST_PTR_FORMAT,caps);

  if (G_UNLIKELY (sink->caps && gst_caps_is_equal (sink->caps, caps))) {
    GST_DEBUG_OBJECT (sink,
        "caps haven't changed, skipping reconfiguration");
    return TRUE;
  }

  structure = gst_caps_get_structure (caps, 0);

  /* we have to differentiate between int and float formats */
  mimetype = gst_structure_get_name (structure);

  if (g_str_equal (mimetype, "audio/x-raw")) {
    GstAudioInfo info;
    sink->caps = caps;
    if (!gst_audio_info_from_caps (&info,caps)){
      return FALSE;
    }
    ret = gst_avb_pcm_sink_parse_audio_info(sink,&info);
    return ret;
  }

  return FALSE;
}
static GstCaps *
gst_avb_pcm_sink_get_caps (GstBaseSink * basesink, GstCaps * filter)
{
  GstCaps *caps;
  GstAvbPcmSink *sink = GST_AVB_PCM_SINK (basesink);
  if ((caps = sink->caps)) {
    if (filter)
      caps = gst_caps_intersect_full (filter, caps, GST_CAPS_INTERSECT_FIRST);
    else
      gst_caps_ref (caps);
  }
  GST_DEBUG_OBJECT (sink, "got caps %" GST_PTR_FORMAT, caps);

  return caps;

}

static gboolean
gst_avb_pcm_sink_process_buffer(GstAvbSink * sink, guint8 *srcBuffer,
  guint32 * offset, guint32 descSize, guint8 * descBuffer, guint64 * outDur)
{
  GstAvbPcmSink *pcmsink;
  guint8 * outPtr;
  guint32 usedSize = 0;
  int i;
  guint32 bpf = (pcmsink->channels / pcmsink->width) / 8;

  if(sink == NULL || srcBuffer == NULL || offset == NULL || descBuffer == NULL)
    return FALSE;

  pcmsink = GST_AVB_PCM_SINK(sink);
  outPtr = descBuffer;
  usedSize = *offset;

  for(i = 0; i < descSize/4; i++){
    *outPtr = pcmsink->label;
    outPtr ++;

    *outPtr = *(srcBuffer+usedSize);
    outPtr ++;
    usedSize ++;

    *outPtr = *(srcBuffer+usedSize);
    outPtr ++;
    usedSize ++;


    if(pcmsink->width == 24){
      *outPtr = *(srcBuffer+usedSize);
      outPtr ++;
      usedSize ++;
    }else{
      outPtr ++;
    }
  }
  //*outDur = gst_util_uint64_scale ((usedSize - *offset)/bpf, GST_SECOND, pcmsink->rate);
  *outDur = (guint64)(usedSize - *offset) * 8 * GST_SECOND/ pcmsink->channels / pcmsink->width / pcmsink->rate;
  *offset = usedSize;
  return TRUE;
}
static void
gst_avb_pcm_sink_class_init (GstAvbPcmSinkClass * klass)
{
  GObjectClass *gobject_class;
  GstElementClass *gstelement_class;
  GstBaseSinkClass *gstbasesink_class;
  GstAvbSinkClass *gstavbsink_class;

  gobject_class = G_OBJECT_CLASS(klass);
  gstelement_class = GST_ELEMENT_CLASS(klass);
  gstbasesink_class = GST_BASE_SINK_CLASS(klass);
  gstavbsink_class = GST_AVBSINK_CLASS(klass);

  gstbasesink_class->set_caps = gst_avb_pcm_sink_set_caps;
  gstbasesink_class->get_caps = gst_avb_pcm_sink_get_caps;

  gstavbsink_class->get_dbs = gst_avb_pcm_sink_get_dbs;
  gstavbsink_class->get_fn = gst_avb_pcm_sink_get_fn;
  gstavbsink_class->get_sph = gst_avb_pcm_sink_get_sph;
  gstavbsink_class->get_dbc = gst_avb_pcm_sink_get_dbc;
  gstavbsink_class->get_fmt = gst_avb_pcm_sink_get_fmt;
  gstavbsink_class->get_fdf = gst_avb_pcm_sink_get_fdf;
  gstavbsink_class->get_syt = gst_avb_pcm_sink_get_syt;

  gstavbsink_class->get_packet_len = gst_avb_pcm_sink_get_packet_len;
  gstavbsink_class->process_buffer = gst_avb_pcm_sink_process_buffer;

  gst_element_class_add_pad_template (gstelement_class,
      gst_static_pad_template_get (&sink_template));

  GST_DEBUG_CATEGORY_INIT (avb_pcm_sink_debug, "avbpcmsink", 0, "freescale avb pcm sink");

  gst_element_class_set_static_metadata (gstelement_class,"avb pcm sink",
      "Sink/Network",
      "Send raw pcm data over 1722 network",
      IMX_GST_PLUGIN_AUTHOR);

  GST_LOG_OBJECT (gobject_class,"gst_avb_pcm_sink_class_init");

}

static void gst_avb_pcm_sink_init (GstAvbPcmSink * sink)
{
  GstBaseSink *basesink;
  GstAvbSink *avbsink;

  sink->caps = NULL;
  sink->width = 0;
  sink->channels = 0;
  sink->rate = 0;
  sink->sfc = 0;
  sink->dbs = 0;
  sink->syt_internal = 0;
  sink->label = 0;

  basesink = GST_BASE_SINK(sink);
  avbsink = GST_AVBSINK(sink);

  gst_avbsink_set_package_count(avbsink,DEFAULT_PACKET_COUNT);

  gstsutils_load_default_property(basesink_property,basesink,
        FSL_GST_CONF_DEFAULT_FILENAME,"avbpcmsink");
  gstsutils_load_default_property(avbsink_property,avbsink,
        FSL_GST_CONF_DEFAULT_FILENAME,"avbpcmsink");

  GST_LOG_OBJECT (sink,"gst_avb_pcm_sink_init");
}