Пример #1
0
void GstPipelineWrapper::EnsureGstreamerInitialization()
{
	if (!gst_is_initialized())
	{
//		int 	argc = 0;
//		char** 	argv = NULL;
		
	    int   argc = 0;
		char  **argv = new char *[2]; 

		argv[argc++] = "--gst-version";
		argv[argc++] = "--gst-debug-level=1";

		gst_init(&argc, &argv);

		delete argv;

		// get and display GST version
		{
		guint	major	= 0;
		guint   minor	= 0;
		guint   micro	= 0;
		guint   nano	= 0;

			gst_version(&major,&minor,&micro,&nano);

			std::cout << "GStreamer V" << major << "." <<
				                          minor << "." <<
										  micro << "." <<
										  nano  << std::endl;
		}
	}
}
Пример #2
0
bool initializeGStreamer()
{
    if (gst_is_initialized())
        return true;

#if ENABLE(SECCOMP_FILTERS)
    // The gst-plugin-scanner helper binary will receive SIGSYS and dump core
    // when it attempts to open a file. Disable it so that plugin scanning
    // occurs in-process. The disadvantage is that a plugin that crashes while
    // loading will now crash the web process.
    gst_registry_fork_set_enabled(FALSE);
#endif

    GUniqueOutPtr<GError> error;
    // FIXME: We should probably pass the arguments from the command line.
    bool gstInitialized = gst_init_check(0, 0, &error.outPtr());
    ASSERT_WITH_MESSAGE(gstInitialized, "GStreamer initialization failed: %s", error ? error->message : "unknown error occurred");

#if ENABLE(VIDEO_TRACK) && USE(GSTREAMER_MPEGTS)
    if (gstInitialized)
        gst_mpegts_initialize();
#endif

    return gstInitialized;
}
Пример #3
0
Player::Backend::Backend(Player * player):
    pipeline_(),
    appsrc_(),
    conv_(),
    audiosink_(),
    loop_(),
    push_id_(),
    bus_watch_id_(),
    player_(player) {
    if(!gst_is_initialized()) {
        GError *err;
        if(!gst_init_check(nullptr,nullptr,&err)) {
            std::exit(err->code);
        }
    }

    pipeline_ = gst_pipeline_new ("pipeline");

    if(pipeline_==nullptr) {
        std::exit(EXIT_FAILURE);
    };

    build_gst_element(appsrc_,"appsrc","source");
    build_gst_element(conv_,"audioconvert","conv");

    GstBus * bus = gst_pipeline_get_bus (GST_PIPELINE (pipeline_));
    bus_watch_id_ = gst_bus_add_watch (bus, wrap_bus_callback, this);
    gst_object_unref (bus);
    
    GstCaps * caps = gst_caps_new_simple(
        "audio/x-raw",
        "format", G_TYPE_STRING, format_,
        "rate", G_TYPE_INT, Config::sample_rate,
        "channels",G_TYPE_INT, Config::channels,
        "signed", G_TYPE_BOOLEAN, TRUE,
        "layout", G_TYPE_STRING, "interleaved",
        nullptr);

    g_object_set(G_OBJECT(appsrc_),"caps",caps,nullptr);
    g_object_set(G_OBJECT(appsrc_),"is-live",true,nullptr);
    g_object_set(G_OBJECT(appsrc_),"min-latency",0,nullptr);
    g_object_set(G_OBJECT(appsrc_),"emit-signals",false,nullptr);
    g_object_set(G_OBJECT(appsrc_),"format",GST_FORMAT_TIME,nullptr);

    //the gstreamer main loop is the main event loop for audio generation
    loop_ = g_main_loop_new (nullptr, FALSE);

    gst_bin_add_many (GST_BIN (pipeline_), appsrc_, conv_, nullptr);
    gst_element_link (appsrc_, conv_);

    GstAppSrcCallbacks callbacks = {wrap_need_data, wrap_enough_data, wrap_seek_data};
    gst_app_src_set_callbacks(GST_APP_SRC(appsrc_), &callbacks, this, nullptr);
}
bool initializeGStreamer()
{
#if GST_CHECK_VERSION(0, 10, 31)
    if (gst_is_initialized())
        return true;
#endif

    GOwnPtr<GError> error;
    // FIXME: We should probably pass the arguments from the command line.
    bool gstInitialized = gst_init_check(0, 0, &error.outPtr());
    ASSERT_WITH_MESSAGE(gstInitialized, "GStreamer initialization failed: %s", error ? error->message : "unknown error occurred");
    return gstInitialized;
}
Пример #5
0
ITSMFDecoder* freerdp_tsmf_client_subsystem_entry(void)
{
	TSMFGstreamerDecoder *decoder;

	if (!gst_is_initialized())
	{
		gst_init(NULL, NULL);
	}

	decoder = calloc(1, sizeof(TSMFGstreamerDecoder));

	if (!decoder)
		return NULL;

	decoder->iface.SetFormat = tsmf_gstreamer_set_format;
	decoder->iface.Decode = NULL;
	decoder->iface.GetDecodedData = NULL;
	decoder->iface.GetDecodedFormat = NULL;
	decoder->iface.GetDecodedDimension = NULL;
	decoder->iface.GetRunningTime = tsmf_gstreamer_get_running_time;
	decoder->iface.UpdateRenderingArea = tsmf_gstreamer_update_rendering_area;
	decoder->iface.Free = tsmf_gstreamer_free;
	decoder->iface.Control = tsmf_gstreamer_control;
	decoder->iface.DecodeEx = tsmf_gstreamer_decodeEx;
	decoder->iface.ChangeVolume = tsmf_gstreamer_change_volume;
	decoder->iface.BufferLevel = tsmf_gstreamer_buffer_level;
	decoder->iface.SetAckFunc = tsmf_gstreamer_ack;
	decoder->iface.SetSyncFunc = tsmf_gstreamer_sync;
	decoder->paused = FALSE;
	decoder->gstVolume = 0.5;
	decoder->gstMuted = FALSE;
	decoder->state = GST_STATE_VOID_PENDING;  /* No real state yet */
	decoder->last_sample_start_time = 0;
	decoder->last_sample_end_time = 0;
	decoder->seek_offset = 0;
	decoder->seeking = FALSE;

	if (tsmf_platform_create(decoder) < 0)
	{
		free(decoder);
		return NULL;
	}

	return (ITSMFDecoder*) decoder;
}
Пример #6
0
/**
 * gst_element_factory_make:
 * @factoryname: a named factory to instantiate
 * @name: (allow-none): name of new element, or %NULL to automatically create
 *    a unique name
 *
 * Create a new element of the type defined by the given element factory.
 * If name is %NULL, then the element will receive a guaranteed unique name,
 * consisting of the element factory name and a number.
 * If name is given, it will be given the name supplied.
 *
 * Returns: (transfer floating) (nullable): new #GstElement or %NULL
 * if unable to create element
 */
GstElement *
gst_element_factory_make (const gchar * factoryname, const gchar * name)
{
  GstElementFactory *factory;
  GstElement *element;

  g_return_val_if_fail (factoryname != NULL, NULL);
  g_return_val_if_fail (gst_is_initialized (), NULL);

  GST_LOG ("gstelementfactory: make \"%s\" \"%s\"",
      factoryname, GST_STR_NULL (name));

  factory = gst_element_factory_find (factoryname);
  if (factory == NULL)
    goto no_factory;

  GST_LOG_OBJECT (factory, "found factory %p", factory);
  element = gst_element_factory_create (factory, name);
  if (element == NULL)
    goto create_failed;

  gst_object_unref (factory);

  return element;

  /* ERRORS */
no_factory:
  {
    GST_WARNING ("no such element factory \"%s\"!", factoryname);
    return NULL;
  }
create_failed:
  {
    GST_INFO_OBJECT (factory, "couldn't create instance!");
    gst_object_unref (factory);
    return NULL;
  }
}
static void
gt_player_backend_gstreamer_cairo_class_init(GtPlayerBackendGstreamerCairoClass* klass)
{
    GObjectClass* obj_class = G_OBJECT_CLASS(klass);

    obj_class->finalize = finalise;
    obj_class->get_property = get_property;
    obj_class->set_property = set_property;

    props[PROP_VOLUME] = g_param_spec_double("volume",
                                             "Volume",
                                             "Volume of player",
                                             0.0, 1.0, 0.3,
                                             G_PARAM_READWRITE | G_PARAM_CONSTRUCT);
    props[PROP_PLAYING] = g_param_spec_boolean("playing",
                                               "Playing",
                                               "Whether playing",
                                               FALSE,
                                               G_PARAM_READABLE | G_PARAM_CONSTRUCT);
    props[PROP_URI] = g_param_spec_string("uri",
                                          "Uri",
                                          "Current uri",
                                          "",
                                          G_PARAM_READWRITE);
    props[PROP_BUFFER_FILL] = g_param_spec_double("buffer-fill",
                                                     "Buffer Fill",
                                                     "Current buffer fill",
                                                     0, 1.0, 0,
                                                     G_PARAM_READWRITE | G_PARAM_CONSTRUCT);

    g_object_class_override_property(obj_class, PROP_VOLUME, "volume");
    g_object_class_override_property(obj_class, PROP_PLAYING, "playing");
    g_object_class_override_property(obj_class, PROP_URI, "uri");
    g_object_class_override_property(obj_class, PROP_BUFFER_FILL, "buffer-fill");

    if (!gst_is_initialized())
        gst_init(NULL, NULL);
}
Пример #8
0
shmdata_any_reader_t *
shmdata_any_reader_init (const char *socketName)
{
  shmdata_any_reader_t *reader =
    (shmdata_any_reader_t *) g_malloc0 (sizeof (shmdata_any_reader_t));
  reader->debug_ = SHMDATA_DISABLE_DEBUG;
  g_log_set_default_handler (shmdata_any_reader_log_handler, reader);
  reader->on_data_ = NULL;
  reader->on_data_user_data_ = NULL;
  reader->type_ = NULL;
  reader->data_caps_ = NULL;
  reader->do_absolute_ = FALSE;
  reader->run_gmainloop_ = TRUE;

  if (!gst_is_initialized())
    gst_init (NULL, NULL);
  reader->loop_ = g_main_loop_new (NULL, FALSE);
  reader->pipeline_ = gst_pipeline_new (NULL);
  if (reader->pipeline_ == NULL)
    g_critical ("cannot create gstreamer pipeline");
  gst_element_set_state (reader->pipeline_, GST_STATE_PLAYING);

  return reader;
}
/**
 * gst_device_provider_factory_get_by_name:
 * @factoryname: a named factory to instantiate
 *
 * Returns the device provider of the type defined by the given device
 * provider factory.
 *
 * Returns: (transfer full) (nullable): a #GstDeviceProvider or %NULL
 * if unable to create device provider
 *
 * Since: 1.4
 */
GstDeviceProvider *
gst_device_provider_factory_get_by_name (const gchar * factoryname)
{
  GstDeviceProviderFactory *factory;
  GstDeviceProvider *device_provider;

  g_return_val_if_fail (factoryname != NULL, NULL);
  g_return_val_if_fail (gst_is_initialized (), NULL);

  GST_LOG ("gstdeviceproviderfactory: get_by_name \"%s\"", factoryname);

  factory = gst_device_provider_factory_find (factoryname);
  if (factory == NULL)
    goto no_factory;

  GST_LOG_OBJECT (factory, "found factory %p", factory);
  device_provider = gst_device_provider_factory_get (factory);
  if (device_provider == NULL)
    goto create_failed;

  gst_object_unref (factory);
  return device_provider;

  /* ERRORS */
no_factory:
  {
    GST_INFO ("no such device provider factory \"%s\"!", factoryname);
    return NULL;
  }
create_failed:
  {
    GST_INFO_OBJECT (factory, "couldn't create instance!");
    gst_object_unref (factory);
    return NULL;
  }
}
Пример #10
0
int main(int, char**)
{
    gst_is_initialized();
    return 0;
}
Пример #11
0
void MediaPlayer::threadLoadMedia()
{
    m_duration = -1;
    m_errorsDetected = false;

    // Initialize gstreamer if not initialized yet
    if ( !gst_is_initialized() )
    {
        //qputenv( "GST_DEBUG", "*:4" );
#ifdef WIN32
        QString env = QString("GST_PLUGIN_PATH=%1\\gstreamer\\") .arg( QApplication::applicationDirPath() );
        env.replace( "/", "\\" );
        _putenv( qPrintable(env) );

        Logger::debug( "GstMediaPlayer: setting %s", qPrintable( env ) );
#endif
        gst_init(0, 0);
    }

    // Create the empty pipeline (this must be done first)
    m_gst_pipeline = gst_pipeline_new ("karaokepipeline");

    if ( !m_gst_pipeline )
    {
        reportError( "Pipeline could not be created." );
        return;
    }

    // Create the pipeline bus
    m_gst_bus = gst_element_get_bus( m_gst_pipeline );

    if ( !m_gst_bus )
    {
        reportError( "Pipeline bus could not be created." );
        return;
    }

    // Set the handler for the bus
    gst_bus_set_sync_handler( m_gst_bus, cb_busMessageDispatcher, this, 0 );

    // Create our media source, which could be either QIODevice/appsrc or a file
    // this also creates a decoder
    setupSource();

    // Those are mandatory
    if ( !m_gst_pipeline || !m_gst_source || !m_gst_decoder )
    {
        reportError( "Not all elements could be created." );
        return;
    }

    // Link and set up source and decoder if they are not the same object.
    if ( m_gst_source != m_gst_decoder )
    {
        if ( !gst_element_link( m_gst_source, m_gst_decoder ) )
        {
            reportError( "Cannot link source and decoder." );
            return;
        }
    }

    // If we do not have raw data, connect to the pad-added signal
    g_signal_connect( m_gst_decoder, "pad-added", G_CALLBACK (cb_pad_added), this );

    // Pre-create video elements if we need them
    if ( (m_loadOptions & MediaPlayer::LoadVideoStream) != 0 )
    {
        m_gst_video_colorconv = createElement( "videoconvert", "videoconvert" );
        m_gst_video_sink = createVideoSink();

        if ( !m_gst_video_colorconv || !m_gst_video_sink )
        {
            reportError( "Not all elements could be created." );
            return;
        }

        // Link the color converter and video sink
        if ( !gst_element_link( m_gst_video_colorconv, m_gst_video_sink ) )
        {
            reportError( "Cannor link video elements" );
            return;
        }
    }

    // Pre-create audio elements if we need them
    if ( (m_loadOptions & MediaPlayer::LoadAudioStream) != 0 )
    {
        // Load the pitch plugin if it is available
        m_pitchPlugin = pPluginManager->loadPitchChanger();

        // Create the audio elements, and add them to the bin
        m_gst_audioconverter = createElement ("audioconvert", "convert");
        m_gst_audio_volume = createElement("volume", "volume");
        m_gst_audiosink = createElement ("autoaudiosink", "sink");

        // Those are mandatory
        if ( !m_gst_audioconverter || !m_gst_audiosink || !m_gst_audio_volume )
        {
            reportError( "Not all elements could be created." );
            return;
        }

        // This one is optional, although it seems to be present everywhere
        m_gst_audio_tempo = createElement( "scaletempo", "tempo", false );

        // If we have the pitch changer
        if ( m_pitchPlugin && m_pitchPlugin->init() )
            m_gst_audio_pitchadjust = createElement( m_pitchPlugin->elementName(), "audiopitchchanger", false );
        else
            m_gst_audio_pitchadjust = 0;

        // Start linking
        bool linksucceed = true;
        GstElement * last = m_gst_audioconverter;

        if ( m_gst_audio_pitchadjust )
        {
            m_gst_audioconverter2 = createElement ("audioconvert", "convert2");

            linksucceed = gst_element_link_many( m_gst_audioconverter, m_gst_audio_pitchadjust, m_gst_audioconverter2, NULL );
            last = m_gst_audioconverter2;
        }

        // Now link in volume
        linksucceed = gst_element_link( last, m_gst_audio_volume );
        last = m_gst_audio_volume;

        // Now link in tempo if it is available
        if ( linksucceed && m_gst_audio_tempo )
        {
            linksucceed = gst_element_link( last, m_gst_audio_tempo );
            last = m_gst_audio_tempo;
        }

        // And finally the audio sink
        if ( linksucceed )
            linksucceed = gst_element_link( last, m_gst_audiosink );

        if ( !linksucceed )
        {
            reportError( "Audio elements could not be linked." );
            return;
        }
    }

    setPipelineState( GST_STATE_PAUSED );
}
Пример #12
0
  bool GSCam::init_stream()
  {
    if(!gst_is_initialized()) {
      // Initialize gstreamer pipeline
      ROS_DEBUG_STREAM( "Initializing gstreamer..." );
      gst_init(0,0);
    }

    ROS_DEBUG_STREAM( "Gstreamer Version: " << gst_version_string() );

    GError *error = 0; // Assignment to zero is a gst requirement

    pipeline_ = gst_parse_launch(gsconfig_.c_str(), &error);
    if (pipeline_ == NULL) {
      ROS_FATAL_STREAM( error->message );
      return false;
    }

    // Create RGB sink
    sink_ = gst_element_factory_make("appsink",NULL);
    GstCaps * caps = image_encoding_ == sensor_msgs::image_encodings::RGB8 ?
        gst_caps_new_simple("video/x-raw-rgb", NULL) :
        gst_caps_new_simple("video/x-raw-gray", NULL);
    gst_app_sink_set_caps(GST_APP_SINK(sink_), caps);
    gst_caps_unref(caps);

    // Set whether the sink should sync
    // Sometimes setting this to true can cause a large number of frames to be
    // dropped
    gst_base_sink_set_sync(
        GST_BASE_SINK(sink_),
        (sync_sink_) ? TRUE : FALSE);

    if(GST_IS_PIPELINE(pipeline_)) {
      GstPad *outpad = gst_bin_find_unlinked_pad(GST_BIN(pipeline_), GST_PAD_SRC);
      g_assert(outpad);

      GstElement *outelement = gst_pad_get_parent_element(outpad);
      g_assert(outelement);
      gst_object_unref(outpad);

      if(!gst_bin_add(GST_BIN(pipeline_), sink_)) {
        ROS_FATAL("gst_bin_add() failed");
        gst_object_unref(outelement);
        gst_object_unref(pipeline_);
        return false;
      }

      if(!gst_element_link(outelement, sink_)) {
        ROS_FATAL("GStreamer: cannot link outelement(\"%s\") -> sink\n", gst_element_get_name(outelement));
        gst_object_unref(outelement);
        gst_object_unref(pipeline_);
        return false;
      }

      gst_object_unref(outelement);
    } else {
      GstElement* launchpipe = pipeline_;
      pipeline_ = gst_pipeline_new(NULL);
      g_assert(pipeline_);

      gst_object_unparent(GST_OBJECT(launchpipe));

      gst_bin_add_many(GST_BIN(pipeline_), launchpipe, sink_, NULL);

      if(!gst_element_link(launchpipe, sink_)) {
        ROS_FATAL("GStreamer: cannot link launchpipe -> sink");
        gst_object_unref(pipeline_);
        return false;
      }
    }

    gst_element_set_state(pipeline_, GST_STATE_PAUSED);

    if (gst_element_get_state(pipeline_, NULL, NULL, -1) == GST_STATE_CHANGE_FAILURE) {
      ROS_FATAL("Failed to PAUSE stream, check your gstreamer configuration.");
      return false;
    } else {
      ROS_DEBUG_STREAM("Stream is PAUSED.");
    }

    // Create ROS camera interface
    camera_pub_ = image_transport_.advertiseCamera("camera/image_raw", 1);

    return true;
  }
static void
gt_player_backend_gstreamer_cairo_class_finalize(GtPlayerBackendGstreamerCairoClass* klass)
{
    if (gst_is_initialized())
        gst_deinit();
}