libextractor

mediagst.c (7588B)

---

 /*
      This file is part of libextractor.
      Copyright (C) 2026 Vidyut Samanta and Christian Grothoff
 
      libextractor is free software; you can redistribute it and/or modify
      it under the terms of the GNU General Public License as published
      by the Free Software Foundation; either version 3, or (at your
      option) any later version.
 
      libextractor 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
      General Public License for more details.
 
      You should have received a copy of the GNU General Public License
      along with libextractor; see the file COPYING.  If not, write to the
      Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
      Boston, MA 02110-1301, USA.
  */
 /**
  * @file plugins/mediagst.c
  * @brief plumbing between an extraction context and a GStreamer pipeline
  * @author Christian Grothoff
  */
 #include "platform.h"
 #include "mediagst.h"
 
 #include <gst/app/gstappsrc.h>
 
 
 /**
  * Implementation of GstAppSrc's "need-data" callback.  Reads data from
  * the extraction context and passes it to GStreamer.
  *
  * @param appsrc the source that ran out of data
  * @param size number of bytes requested
  * @param io our execution context
  */
 static void
 feed_data (GstElement *appsrc,
            guint size,
            struct EXTRACTOR_GstIO *io)
 {
   GstBuffer *buffer;
   GstMemory *mem;
   GstMapInfo mi;
   guint accumulated;
   ssize_t data_len;
   uint8_t *le_data;
 
   if ( (0 != io->length) &&
        (io->offset >= io->length) )
   {
     gst_app_src_end_of_stream (GST_APP_SRC (appsrc));
     return;
   }
   if ( (0 != io->length) &&
        (io->offset + size > io->length) )
     size = io->length - io->offset;
   if (0 == size)
   {
     gst_app_src_end_of_stream (GST_APP_SRC (appsrc));
     return;
   }
   mem = gst_allocator_alloc (NULL, size, NULL);
   if (! gst_memory_map (mem, &mi, GST_MAP_WRITE))
   {
     gst_memory_unref (mem);
     gst_app_src_end_of_stream (GST_APP_SRC (appsrc));
     return;
   }
   accumulated = 0;
   data_len = 1;
   while ( (accumulated < size) &&
           (data_len > 0) )
   {
     data_len = io->ec->read (io->ec->cls,
                              (void **) &le_data,
                              size - accumulated);
     if (data_len > 0)
     {
       memcpy (&mi.data[accumulated],
               le_data,
               data_len);
       accumulated += data_len;
     }
   }
   gst_memory_unmap (mem, &mi);
   if (0 == accumulated)
   {
     gst_memory_unref (mem);
     gst_app_src_end_of_stream (GST_APP_SRC (appsrc));
     return;
   }
   gst_memory_resize (mem, 0, accumulated);
   buffer = gst_buffer_new ();
   gst_buffer_append_memory (buffer, mem);
   /* the offsets matter: they are what makes random access work */
   GST_BUFFER_OFFSET (buffer) = io->offset;
   GST_BUFFER_OFFSET_END (buffer) = io->offset + accumulated;
   io->offset += accumulated;
   gst_app_src_push_buffer (GST_APP_SRC (appsrc), buffer);
 }
 
 
 /**
  * Implementation of GstAppSrc's "seek-data" callback.
  *
  * @param appsrc the source that wants to seek
  * @param position new desired absolute position in the file
  * @param io our execution context
  * @return TRUE if seeking succeeded
  */
 static gboolean
 seek_data (GstElement *appsrc,
            guint64 position,
            struct EXTRACTOR_GstIO *io)
 {
   int64_t ret;
 
   (void) appsrc;
   ret = io->ec->seek (io->ec->cls,
                       position,
                       SEEK_SET);
   if (0 > ret)
     return FALSE;
   io->offset = (uint64_t) ret;
   return io->offset == position;
 }
 
 
 /**
  * Implementation of playbin's "source-setup" signal: configure the
  * appsrc it created for our "appsrc://" URI.
  *
  * @param playbin the pipeline
  * @param source the appsrc to configure
  * @param io our execution context
  */
 static void
 source_setup (GstElement *playbin,
               GstElement *source,
               struct EXTRACTOR_GstIO *io)
 {
   (void) playbin;
   if (0 != io->length)
     g_object_set (source,
                   "size", (gint64) io->length,
                   "stream-type", GST_APP_STREAM_TYPE_RANDOM_ACCESS,
                   NULL);
   else
     g_object_set (source,
                   "size", (gint64) - 1,
                   "stream-type", GST_APP_STREAM_TYPE_STREAM,
                   NULL);
   g_object_set (source,
                 "format", GST_FORMAT_BYTES,
                 NULL);
   g_signal_connect (source,
                     "need-data",
                     G_CALLBACK (&feed_data),
                     io);
   g_signal_connect (source,
                     "seek-data",
                     G_CALLBACK (&seek_data),
                     io);
 }
 
 
 GstElement *
 EXTRACTOR_gst_playbin_ (struct EXTRACTOR_GstIO *io,
                         struct EXTRACTOR_ExtractContext *ec,
                         unsigned int flags,
                         GstElement *video_sink,
                         GstElement *audio_sink)
 {
   GstElement *pipeline;
   uint64_t size;
 
   if (! gst_is_initialized ())
     gst_init (NULL, NULL);
   io->ec = ec;
   io->offset = 0;
   size = ec->get_size (ec->cls);
   io->length = (UINT64_MAX == size) ? 0 : size;
   pipeline = gst_element_factory_make ("playbin", NULL);
   if ( (NULL == pipeline) ||
        (NULL == video_sink) ||
        (NULL == audio_sink) )
   {
     /* gst-plugins-base is not installed, or not completely */
     if (NULL != video_sink)
       gst_object_unref (video_sink);
     if (NULL != audio_sink)
       gst_object_unref (audio_sink);
     if (NULL != pipeline)
       gst_object_unref (pipeline);
     return NULL;
   }
   g_object_set (pipeline,
                 "uri", "appsrc://",
                 "video-sink", video_sink,
                 "audio-sink", audio_sink,
                 "flags", flags,
                 NULL);
   g_signal_connect (pipeline,
                     "source-setup",
                     G_CALLBACK (&source_setup),
                     io);
   return pipeline;
 }
 
 
 int
 EXTRACTOR_gst_wait_async_ (GstElement *pipeline,
                            GstClockTime timeout)
 {
   GstBus *bus;
   GstMessage *msg;
   int ret = 0;
 
   if (0 == timeout)
     return 0;
   if (NULL == (bus = gst_element_get_bus (pipeline)))
     return 0;
   while (1)
   {
     msg = gst_bus_timed_pop_filtered (bus,
                                       timeout,
                                       GST_MESSAGE_ASYNC_DONE
                                       | GST_MESSAGE_ERROR
                                       | GST_MESSAGE_EOS);
     if (NULL == msg)
       break;   /* timed out */
     if (GST_MESSAGE_ASYNC_DONE != GST_MESSAGE_TYPE (msg))
     {
       /* an error, or the file ended before we ever saw a frame */
       gst_message_unref (msg);
       break;
     }
     if (GST_OBJECT (pipeline) == GST_MESSAGE_SRC (msg))
     {
       gst_message_unref (msg);
       ret = 1;
       break;
     }
     /* ASYNC_DONE from some element inside the pipeline; keep waiting */
     gst_message_unref (msg);
   }
   gst_object_unref (bus);
   return ret;
 }
 
 
 gint64
 EXTRACTOR_gst_sample_position_ (GstElement *pipeline,
                                 unsigned int offset,
                                 gint64 *duration)
 {
   gint64 target;
   gint64 dur = 0;
 
   target = ((gint64) offset) * GST_SECOND;
   if (! gst_element_query_duration (pipeline,
                                     GST_FORMAT_TIME,
                                     &dur))
     dur = 0;
   if (dur < 0)
     dur = 0;
   if ( (0 != dur) &&
        (target > dur / 3) )
     target = dur / 3;
   *duration = dur;
   return target;
 }
 
 
 /* end of mediagst.c */