/* GStreamer

 * Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>

 *               2000,2005 Wim Taymans <wim@fluendo.com>

 *

 * gstfilesrc.c:

 *

 * 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.

 */

/**

 * SECTION:element-filesrc

 * @short_description: read from arbitrary point in a file

 * @see_also: #GstFileSrc

 *

 * Read data from a file in the local file system.

 */

#ifdef HAVE_CONFIG_H

#  include "config.h"

#endif

#ifdef __SYMBIAN32__

#include <gst_global.h>

#endif

#include <gst/gst.h>

#include "gstfilesrc.h"

#include <stdio.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>

#ifdef __SYMBIAN32__

#include <glib_global.h>

#include <gobject_global.h>

#endif

#ifdef HAVE_UNISTD_H

#  include <unistd.h>

#endif

#ifdef HAVE_MMAP

# include <sys/mman.h>

#endif

#ifdef HAVE_WIN32

#  include <io.h>               /* lseek, open, close, read */

#endif

#include <errno.h>

#include <string.h>

#include "../../gst/gst-i18n-lib.h"

#include <gstelement.h>

static GstStaticPadTemplate srctemplate = GST_STATIC_PAD_TEMPLATE ("src",

    GST_PAD_SRC,

    GST_PAD_ALWAYS,

    GST_STATIC_CAPS_ANY);

/* FIXME we should be using glib for this */

#ifndef S_ISREG

#define S_ISREG(mode) ((mode)&_S_IFREG)

#endif

#ifndef S_ISDIR

#define S_ISDIR(mode) ((mode)&_S_IFDIR)

#endif

#ifndef S_ISSOCK

#define S_ISSOCK(x) (0)

#endif

#ifndef O_BINARY

#define O_BINARY (0)

#endif

/**********************************************************************

 * GStreamer Default File Source

 * Theory of Operation

 *

 * Update: see GstFileSrc:use-mmap property documentation below

 *         for why use of mmap() is disabled by default.

 *

 * This source uses mmap(2) to efficiently load data from a file.

 * To do this without seriously polluting the applications' memory

 * space, it must do so in smaller chunks, say 1-4MB at a time.

 * Buffers are then subdivided from these mmap'd chunks, to directly

 * make use of the mmap.

 *

 * To handle refcounting so that the mmap can be freed at the appropriate

 * time, a buffer will be created for each mmap'd region, and all new

 * buffers will be sub-buffers of this top-level buffer.  As they are

 * freed, the refcount goes down on the mmap'd buffer and its free()

 * function is called, which will call munmap(2) on itself.

 *

 * If a buffer happens to cross the boundaries of an mmap'd region, we

 * have to decide whether it's more efficient to copy the data into a

 * new buffer, or mmap() just that buffer.  There will have to be a

 * breakpoint size to determine which will be done.  The mmap() size

 * has a lot to do with this as well, because you end up in double-

 * jeopardy: the larger the outgoing buffer, the more data to copy when

 * it overlaps, *and* the more frequently you'll have buffers that *do*

 * overlap.

 *

 * Seeking is another tricky aspect to do efficiently.  The initial

 * implementation of this source won't make use of these features, however.

 * The issue is that if an application seeks backwards in a file, *and*

 * that region of the file is covered by an mmap that hasn't been fully

 * deallocated, we really should re-use it.  But keeping track of these

 * regions is tricky because we have to lock the structure that holds

 * them.  We need to settle on a locking primitive (GMutex seems to be

 * a really good option...), then we can do that.

 */

GST_DEBUG_CATEGORY_STATIC (gst_file_src_debug);

#define GST_CAT_DEFAULT gst_file_src_debug

/* FileSrc signals and args */

enum

{

  /* FILL ME */

  LAST_SIGNAL

};

#define DEFAULT_BLOCKSIZE       4*1024

#define DEFAULT_MMAPSIZE        4*1024*1024

#define DEFAULT_TOUCH           TRUE

#define DEFAULT_USEMMAP         FALSE

#define DEFAULT_SEQUENTIAL      FALSE

enum

{

  ARG_0,

  ARG_LOCATION,

  ARG_FD,

  ARG_MMAPSIZE,

  ARG_SEQUENTIAL,

  ARG_TOUCH,

  ARG_USEMMAP

};

static void gst_file_src_finalize (GObject * object);

static void gst_file_src_set_property (GObject * object, guint prop_id,

    const GValue * value, GParamSpec * pspec);

static void gst_file_src_get_property (GObject * object, guint prop_id,

    GValue * value, GParamSpec * pspec);

static gboolean gst_file_src_start (GstBaseSrc * basesrc);

static gboolean gst_file_src_stop (GstBaseSrc * basesrc);

static gboolean gst_file_src_is_seekable (GstBaseSrc * src);

static gboolean gst_file_src_get_size (GstBaseSrc * src, guint64 * size);

static GstFlowReturn gst_file_src_create (GstBaseSrc * src, guint64 offset,

    guint length, GstBuffer ** buffer);

static void gst_file_src_uri_handler_init (gpointer g_iface,

    gpointer iface_data);

static void

_do_init (GType filesrc_type)

{

  static const GInterfaceInfo urihandler_info = {

    gst_file_src_uri_handler_init,

    NULL,

    NULL

  };

  g_type_add_interface_static (filesrc_type, GST_TYPE_URI_HANDLER,

      &urihandler_info);

  GST_DEBUG_CATEGORY_INIT (gst_file_src_debug, "filesrc", 0, "filesrc element");

}

GST_BOILERPLATE_FULL (GstFileSrc, gst_file_src, GstBaseSrc, GST_TYPE_BASE_SRC,

    _do_init);

static void

gst_file_src_base_init (gpointer g_class)

{

  GstElementClass *gstelement_class = GST_ELEMENT_CLASS (g_class);

  gst_element_class_set_details_simple (gstelement_class,

      "File Source",

      "Source/File",

      "Read from arbitrary point in a file",

      "Erik Walthinsen <omega@cse.ogi.edu>");

  gst_element_class_add_pad_template (gstelement_class,

      gst_static_pad_template_get (&srctemplate));

}

static void

gst_file_src_class_init (GstFileSrcClass * klass)

{

  GObjectClass *gobject_class;

  GstElementClass *gstelement_class;

  GstBaseSrcClass *gstbasesrc_class;

  gobject_class = G_OBJECT_CLASS (klass);

  gstelement_class = GST_ELEMENT_CLASS (klass);

  gstbasesrc_class = GST_BASE_SRC_CLASS (klass);

  gobject_class->set_property = gst_file_src_set_property;

  gobject_class->get_property = gst_file_src_get_property;

  g_object_class_install_property (gobject_class, ARG_FD,

      g_param_spec_int ("fd", "File-descriptor",

          "File-descriptor for the file being mmap()d", 0, G_MAXINT, 0,

          G_PARAM_READABLE));

  g_object_class_install_property (gobject_class, ARG_LOCATION,

      g_param_spec_string ("location", "File Location",

          "Location of the file to read", NULL, G_PARAM_READWRITE));

  g_object_class_install_property (gobject_class, ARG_MMAPSIZE,

      g_param_spec_ulong ("mmapsize", "mmap() Block Size",

          "Size in bytes of mmap()d regions", 0, G_MAXULONG, DEFAULT_MMAPSIZE,

          G_PARAM_READWRITE));

  g_object_class_install_property (gobject_class, ARG_TOUCH,

      g_param_spec_boolean ("touch", "Touch mapped region read data",

          "Touch mmapped data regions to force them to be read from disk",

          DEFAULT_TOUCH, G_PARAM_READWRITE));

  /**

   * GstFileSrc:use-mmap

   *

   * Whether to use mmap(). Set to TRUE to force use of mmap() instead of

   * read() for reading data.

   *

   * Use of mmap() is disabled by default since with mmap() there are a

   * number of occasions where the process/application will be notified of

   * read errors via a SIGBUS signal from the kernel, which will lead to

   * the application being killed if not handled by the application. This

   * is something that is difficult to work around for a library like

   * GStreamer, hence use of mmap() is disabled by default. Said errors

   * can occur for example when an external device (e.g. an external hard

   * drive or a portable music player) are unplugged while in use, or when

   * a CD/DVD medium cannot be be read because the medium is scratched or

   * otherwise damaged.

   *

   **/

  g_object_class_install_property (gobject_class, ARG_USEMMAP,

      g_param_spec_boolean ("use-mmap", "Use mmap to read data",

          "Whether to use mmap() instead of read()",

          DEFAULT_USEMMAP, G_PARAM_READWRITE));

  g_object_class_install_property (gobject_class, ARG_SEQUENTIAL,

      g_param_spec_boolean ("sequential", "Optimise for sequential mmap access",

          "Whether to use madvise to hint to the kernel that access to "

          "mmap pages will be sequential",

          DEFAULT_SEQUENTIAL, G_PARAM_READWRITE));

  gobject_class->finalize = GST_DEBUG_FUNCPTR (gst_file_src_finalize);

  gstbasesrc_class->start = GST_DEBUG_FUNCPTR (gst_file_src_start);

  gstbasesrc_class->stop = GST_DEBUG_FUNCPTR (gst_file_src_stop);

  gstbasesrc_class->is_seekable = GST_DEBUG_FUNCPTR (gst_file_src_is_seekable);

  gstbasesrc_class->get_size = GST_DEBUG_FUNCPTR (gst_file_src_get_size);

  gstbasesrc_class->create = GST_DEBUG_FUNCPTR (gst_file_src_create);

  if (sizeof (off_t) < 8) {

    GST_LOG ("No large file support, sizeof (off_t) = %" G_GSIZE_FORMAT "!",

        sizeof (off_t));

  }

}

static void

gst_file_src_init (GstFileSrc * src, GstFileSrcClass * g_class)

{

#ifdef HAVE_MMAP

  src->pagesize = getpagesize ();

#endif

  src->filename = NULL;

  src->fd = 0;

  src->uri = NULL;

  src->touch = DEFAULT_TOUCH;

  src->mapbuf = NULL;

  src->mapsize = DEFAULT_MMAPSIZE;      /* default is 4MB */

  src->use_mmap = DEFAULT_USEMMAP;

  src->sequential = DEFAULT_SEQUENTIAL;

  src->is_regular = FALSE;

}

static void

gst_file_src_finalize (GObject * object)

{

  GstFileSrc *src;

  src = GST_FILE_SRC (object);

  g_free (src->filename);

  g_free (src->uri);

  G_OBJECT_CLASS (parent_class)->finalize (object);

}

static gboolean

gst_file_src_set_location (GstFileSrc * src, const gchar * location)

{

  GstState state;

  /* the element must be stopped in order to do this */

  GST_OBJECT_LOCK (src);

  state = GST_STATE (src);

  if (state != GST_STATE_READY && state != GST_STATE_NULL)

    goto wrong_state;

  GST_OBJECT_UNLOCK (src);

  g_free (src->filename);

  g_free (src->uri);

  /* clear the filename if we get a NULL (is that possible?) */

  if (location == NULL) {

    src->filename = NULL;

    src->uri = NULL;

  } else {

    src->filename = g_strdup (location);

    src->uri = gst_uri_construct ("file", src->filename);

  }

  g_object_notify (G_OBJECT (src), "location");

  gst_uri_handler_new_uri (GST_URI_HANDLER (src), src->uri);

  return TRUE;

  /* ERROR */

wrong_state:

  {

    GST_DEBUG_OBJECT (src, "setting location in wrong state");

    GST_OBJECT_UNLOCK (src);

    return FALSE;

  }

}

static void

gst_file_src_set_property (GObject * object, guint prop_id,

    const GValue * value, GParamSpec * pspec)

{

  GstFileSrc *src;

  g_return_if_fail (GST_IS_FILE_SRC (object));

  src = GST_FILE_SRC (object);

  switch (prop_id) {

    case ARG_LOCATION:

      gst_file_src_set_location (src, g_value_get_string (value));

      break;

    case ARG_MMAPSIZE:

      if ((src->mapsize % src->pagesize) == 0) {

        src->mapsize = g_value_get_ulong (value);

      } else {

        GST_INFO_OBJECT (src,

            "invalid mapsize, must be a multiple of pagesize, which is %d",

            src->pagesize);

      }

      break;

    case ARG_TOUCH:

      src->touch = g_value_get_boolean (value);

      break;

    case ARG_SEQUENTIAL:

      src->sequential = g_value_get_boolean (value);

      break;

    case ARG_USEMMAP:

      src->use_mmap = g_value_get_boolean (value);

      break;

    default:

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

      break;

  }

}

static void

gst_file_src_get_property (GObject * object, guint prop_id, GValue * value,

    GParamSpec * pspec)

{

  GstFileSrc *src;

  g_return_if_fail (GST_IS_FILE_SRC (object));

  src = GST_FILE_SRC (object);

  switch (prop_id) {

    case ARG_LOCATION:

      g_value_set_string (value, src->filename);

      break;

    case ARG_FD:

      g_value_set_int (value, src->fd);

      break;

    case ARG_MMAPSIZE:

      g_value_set_ulong (value, src->mapsize);

      break;

    case ARG_TOUCH:

      g_value_set_boolean (value, src->touch);

      break;

    case ARG_SEQUENTIAL:

      g_value_set_boolean (value, src->sequential);

      break;

    case ARG_USEMMAP:

      g_value_set_boolean (value, src->use_mmap);

      break;

    default:

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

      break;

  }

}

/***

 * mmap code below

 */

#ifdef HAVE_MMAP

/* GstMmapBuffer */

typedef struct _GstMmapBuffer GstMmapBuffer;

typedef struct _GstMmapBufferClass GstMmapBufferClass;

#define GST_TYPE_MMAP_BUFFER                         (gst_mmap_buffer_get_type())

#define GST_IS_MMAP_BUFFER(obj)  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GST_TYPE_MMAP_BUFFER))

#define GST_IS_MMAP_BUFFER_CLASS(klass)  (G_TYPE_CHECK_CLASS_TYPE ((klass), GST_TYPE_MMAP_BUFFER))

#define GST_MMAP_BUFFER_GET_CLASS(obj)   (G_TYPE_INSTANCE_GET_CLASS ((obj), GST_TYPE_MMAP_BUFFER, GstMmapBufferClass))

#define GST_MMAP_BUFFER(obj)     (G_TYPE_CHECK_INSTANCE_CAST ((obj), GST_TYPE_MMAP_BUFFER, GstMmapBuffer))

#define GST_MMAP_BUFFER_CLASS(klass)  (G_TYPE_CHECK_CLASS_CAST ((klass), GST_TYPE_MMAP_BUFFER, GstMmapBufferClass))

struct _GstMmapBuffer

{

  GstBuffer buffer;

  GstFileSrc *filesrc;

};

struct _GstMmapBufferClass

{

  GstBufferClass buffer_class;

};

static void gst_mmap_buffer_init (GTypeInstance * instance, gpointer g_class);

static void gst_mmap_buffer_class_init (gpointer g_class, gpointer class_data);

static void gst_mmap_buffer_finalize (GstMmapBuffer * mmap_buffer);

static GstBufferClass *mmap_buffer_parent_class = NULL;

static GType

gst_mmap_buffer_get_type (void)

{

  static GType _gst_mmap_buffer_type;

  if (G_UNLIKELY (_gst_mmap_buffer_type == 0)) {

    static const GTypeInfo mmap_buffer_info = {

      sizeof (GstMmapBufferClass),

      NULL,

      NULL,

      gst_mmap_buffer_class_init,

      NULL,

      NULL,

      sizeof (GstMmapBuffer),

      0,

      gst_mmap_buffer_init,

      NULL

    };

    _gst_mmap_buffer_type = g_type_register_static (GST_TYPE_BUFFER,

        "GstMmapBuffer", &mmap_buffer_info, 0);

  }

  return _gst_mmap_buffer_type;

}

static void

gst_mmap_buffer_class_init (gpointer g_class, gpointer class_data)

{

  GstMiniObjectClass *mini_object_class = GST_MINI_OBJECT_CLASS (g_class);

  mmap_buffer_parent_class = g_type_class_peek_parent (g_class);

  mini_object_class->finalize =

      (GstMiniObjectFinalizeFunction) gst_mmap_buffer_finalize;

}

static void

gst_mmap_buffer_init (GTypeInstance * instance, gpointer g_class)

{

  GstBuffer *buf = (GstBuffer *) instance;

  GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_READONLY);

  /* before we re-enable this flag, we probably need to fix _copy()

   * _make_writable(), etc. in GstMiniObject/GstBuffer as well */

  /* GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_ORIGINAL); */

}

static void

gst_mmap_buffer_finalize (GstMmapBuffer * mmap_buffer)

{

  guint size;

  gpointer data;

  guint64 offset;

  GstFileSrc *src;

  GstBuffer *buffer = GST_BUFFER (mmap_buffer);

  /* get info */

  size = GST_BUFFER_SIZE (buffer);

  offset = GST_BUFFER_OFFSET (buffer);

  data = GST_BUFFER_DATA (buffer);

  src = mmap_buffer->filesrc;

  GST_LOG ("freeing mmap()d buffer at %" G_GUINT64_FORMAT "+%u", offset, size);

#ifdef MADV_DONTNEED

  /* madvise to tell the kernel what to do with it */

  if (madvise (data, size, MADV_DONTNEED) < 0) {

    GST_WARNING_OBJECT (src, "warning: madvise failed: %s", g_strerror (errno));

  }

#endif

  /* now unmap the memory */

  if (munmap (data, size) < 0) {