/*
 * GStreamer
 * Copyright (C) 2013 Fluendo S.L. <support@fluendo.com>
 *    Authors: Andoni Morales Alastruey <amorales@fluendo.com>
 *
 * 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-plugin
 *
 * Read and decode samples from iOS assets using the AVAssetReader API.
 *
 * <refsect2>
 * <title>Example launch line</title>
 * |[
 * gst-launch -v -m iosavassetsrc uri="file://movie.mp4" ! autovideosink
 * ]|
 * </refsect2>
 */

#ifdef HAVE_CONFIG_H
#  include <config.h>
#endif

#include <gst/gst.h>

#include "iosavassetsrc.h"
#include "coremediabuffer.h"
#import <AVFoundation/AVFoundation.h>

GST_DEBUG_CATEGORY_STATIC (gst_avasset_src_debug);
#define GST_CAT_DEFAULT gst_avasset_src_debug

#define CMTIME_TO_GST_TIME(x) \
    (x.value == 0 ? 0 : (guint64)(x.value * GST_SECOND / x.timescale));
#define GST_AVASSET_SRC_LOCK(x) (g_mutex_lock (&x->lock));
#define GST_AVASSET_SRC_UNLOCK(x) (g_mutex_unlock (&x->lock));
#define MEDIA_TYPE_TO_STR(x) \
    (x == GST_AVASSET_READER_MEDIA_TYPE_AUDIO ? "audio" : "video")
#define AVASSET_READER_HAS_AUDIO(x) \
    ([self->reader hasMediaType:GST_AVASSET_READER_MEDIA_TYPE_AUDIO])
#define AVASSET_READER_HAS_VIDEO(x) \
    ([self->reader hasMediaType:GST_AVASSET_READER_MEDIA_TYPE_VIDEO])
#define OBJC_CALLOUT_BEGIN() \
   NSAutoreleasePool *pool; \
   \
   pool = [[NSAutoreleasePool alloc] init]
#define OBJC_CALLOUT_END() \
  [pool release]

enum
{
  PROP_0,
  PROP_URI
};

#define COMMON_CAPS "endianness = (int) {" G_STRINGIFY (G_BYTE_ORDER) " }, " \
        "signed = (boolean) { TRUE }, " \
        "rate = (int) [1, MAX], " \
        "channels = (int) [1, 2];"

static GstStaticPadTemplate audio_factory = GST_STATIC_PAD_TEMPLATE ("audio",
    GST_PAD_SRC,
    GST_PAD_SOMETIMES,
    GST_STATIC_CAPS (
        "audio/x-raw-float, width = (int) 32, depth = (int) 32, " COMMON_CAPS)
    );

static GstStaticPadTemplate video_factory = GST_STATIC_PAD_TEMPLATE ("video",
    GST_PAD_SRC,
    GST_PAD_SOMETIMES,
    GST_STATIC_CAPS ("video/x-raw-yuv, format=(fourcc)NV12, "
        "framerate = (fraction) [ 0, MAX ], "
        "width = (int) [1, MAX], "
        "height = (int) [1, MAX]")
    );

static void gst_avasset_src_set_property (GObject * object, guint prop_id,
    const GValue * value, GParamSpec * pspec);
static void gst_avasset_src_get_property (GObject * object, guint prop_id,
    GValue * value, GParamSpec * pspec);
static void gst_avasset_src_dispose (GObject *object);

static GstStateChangeReturn gst_avasset_src_change_state (GstElement * element,
    GstStateChange transition);

static gboolean gst_avasset_src_query (GstPad *pad, GstQuery *query);
static gboolean gst_avasset_src_event (GstPad *pad, GstEvent *event);
static gboolean gst_avasset_src_send_event (GstAVAssetSrc *self,
    GstEvent *event);

static void gst_avasset_src_read_audio (GstAVAssetSrc *self);
static void gst_avasset_src_read_video (GstAVAssetSrc *self);
static void gst_avasset_src_start (GstAVAssetSrc *self);
static void gst_avasset_src_stop (GstAVAssetSrc *self);
static void gst_avasset_src_start_reading (GstAVAssetSrc *self);
static void gst_avasset_src_stop_reading (GstAVAssetSrc *self);
static void gst_avasset_src_stop_all (GstAVAssetSrc *self);
static void gst_avasset_src_uri_handler_init (gpointer g_iface,
    gpointer iface_data);

static void
_do_init (GType avassetsrc_type)
{
  static const GInterfaceInfo urihandler_info = {
    gst_avasset_src_uri_handler_init,
    NULL,
    NULL
  };

  g_type_add_interface_static (avassetsrc_type, GST_TYPE_URI_HANDLER,
      &urihandler_info);
  GST_DEBUG_CATEGORY_INIT (gst_avasset_src_debug, "iosavassetsrc",
      0, "iosavassetsrc element");
}

GST_BOILERPLATE_FULL (GstAVAssetSrc, gst_avasset_src, GstElement,
    GST_TYPE_ELEMENT, _do_init);

/* GObject vmethod implementations */

static void
gst_avasset_src_base_init (gpointer gclass)
{
  GstElementClass *element_class = GST_ELEMENT_CLASS (gclass);

  gst_element_class_set_details_simple(element_class,
    "Source and decoder for iOS assets",
    "Source/Codec",
    "Read and decode samples from iOS assets using the AVAssetReader API",
    "Andoni Morales Alastruey amorales@fluendo.com");

  gst_element_class_add_pad_template (element_class,
      gst_static_pad_template_get (&audio_factory));
  gst_element_class_add_pad_template (element_class,
      gst_static_pad_template_get (&video_factory));
}

static void
gst_avasset_src_class_init (GstAVAssetSrcClass * klass)
{
  GObjectClass *gobject_class;
  GstElementClass *gstelement_class;

  gobject_class = (GObjectClass *) klass;
  gstelement_class = (GstElementClass *) klass;

  gobject_class->set_property = gst_avasset_src_set_property;
  gobject_class->get_property = gst_avasset_src_get_property;
  gobject_class->dispose = gst_avasset_src_dispose;

  /**
   * GstAVAssetSrc:uri
   *
   * URI of the asset to read
   *
   **/
  g_object_class_install_property (gobject_class, PROP_URI,
      g_param_spec_string ("uri", "Asset URI",
          "URI of the asset to read", NULL,
          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS |
          GST_PARAM_MUTABLE_READY));

  gstelement_class->change_state = gst_avasset_src_change_state;

}

static void
gst_avasset_src_init (GstAVAssetSrc * self, GstAVAssetSrcClass * gclass)
{
  self->audio_task = gst_task_create (
      (GstTaskFunction) gst_avasset_src_read_audio, self);
  self->video_task = gst_task_create (
      (GstTaskFunction) gst_avasset_src_read_video, self);
  gst_task_set_lock (self->video_task, &self->video_lock);
  gst_task_set_lock (self->audio_task, &self->audio_lock);
  self->selected_audio_track = 0;
  self->selected_video_track = 0;
  g_mutex_init(&self->lock);
}

static void
gst_avasset_src_dispose (GObject *object)
{
  GstAVAssetSrc *self = GST_AVASSET_SRC (object);

  if (self->video_task != NULL) {
    gst_object_unref (self->video_task);
    self->video_task = NULL;
  }

  if (self->audio_task) {
    gst_object_unref (self->audio_task);
    self->audio_task = NULL;
  }

  if (self->uri != NULL) {
    g_free (self->uri);
    self->uri = NULL;
  }

  if (self->seek_event) {
    gst_event_unref (self->seek_event);
    self->seek_event = NULL;
  }
}

static void
gst_avasset_src_set_property (GObject * object, guint prop_id,
    const GValue * value, GParamSpec * pspec)
{
  GstAVAssetSrc *self = GST_AVASSET_SRC (object);

  switch (prop_id) {
    case PROP_URI:
      if (self->uri) {
        g_free (self->uri);
      }
      self->uri = g_value_dup_string (value);
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
  }
}

static void
gst_avasset_src_get_property (GObject * object, guint prop_id,
    GValue * value, GParamSpec * pspec)
{
  GstAVAssetSrc *self = GST_AVASSET_SRC (object);

  switch (prop_id) {
    case PROP_URI:
      g_value_set_string (value, self->uri);
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
  }
}

static GstStateChangeReturn
gst_avasset_src_change_state (GstElement * element, GstStateChange transition)
{
  GstAVAssetSrc *self = GST_AVASSET_SRC (element);
  GstStateChangeReturn ret;
  GError *error;

  OBJC_CALLOUT_BEGIN ();
  switch (transition) {
    case GST_STATE_CHANGE_NULL_TO_READY: {
      self->state = GST_AVASSET_SRC_STATE_STOPPED;
      self->reader = [[GstAVAssetReader alloc] initWithURI:self->uri:&error];
      if (error) {
        GST_ELEMENT_ERROR (element, RESOURCE, FAILED, ("AVAssetReader error"),
            ("%s", error->message));
        g_error_free (error);
        gst_avasset_src_stop_all (self);
        return GST_STATE_CHANGE_FAILURE;
      }
      break;
    }
    case GST_STATE_CHANGE_READY_TO_PAUSED:
      gst_avasset_src_start (self);
      self->state = GST_AVASSET_SRC_STATE_STARTED;
      gst_avasset_src_start_reading (self);
      self->state = GST_AVASSET_SRC_STATE_READING;
      break;
    case GST_STATE_CHANGE_PAUSED_TO_PLAYING:
      break;
    default:
      break;
  }

  ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);

  switch (transition) {
    case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
      break;
    case GST_STATE_CHANGE_PAUSED_TO_READY:
      gst_avasset_src_stop_all (self);
      break;
    case GST_STATE_CHANGE_READY_TO_NULL:
      [self->reader release];
      break;
    default:
      break;
  }
  OBJC_CALLOUT_END ();
  return ret;
}

static gboolean
gst_avasset_src_query (GstPad *pad, GstQuery *query)
{
    gboolean ret;
    GstAVAssetSrc *self = GST_AVASSET_SRC (gst_pad_get_parent_element(pad));

    switch (GST_QUERY_TYPE (query)) {
      case GST_QUERY_URI:
        gst_query_set_uri (query, self->uri);
        ret = TRUE;
        break;
      case GST_QUERY_DURATION:
        gst_query_set_duration (query, GST_FORMAT_TIME, self->reader.duration);
        ret = TRUE;
        break;
     case GST_QUERY_POSITION:
        gst_query_set_position (query, GST_FORMAT_TIME, self->reader.position);
        ret = TRUE;
        break;
     default:
        ret = FALSE;
        break;
    }

    g_object_unref(self);
    return ret;
}

static gboolean
gst_avasset_src_event (GstPad * pad, GstEvent * event)
{
  GstAVAssetSrc *self;
  gboolean res = TRUE;
  GError *error = NULL;

  OBJC_CALLOUT_BEGIN ();
  self = GST_AVASSET_SRC (gst_pad_get_parent_element (pad));

  switch (GST_EVENT_TYPE (event)) {
    case GST_EVENT_SEEK: {
      GstFormat format;
      GstSeekFlags flags;
      gdouble rate;
      GstSeekType start_type, stop_type;
      gint64 start, stop;
      GstEvent *newsegment;

      /* now do the seek */
      GST_AVASSET_SRC_LOCK (self);
      if (self->seek_event && gst_event_get_seqnum (event) ==
          gst_event_get_seqnum (self->seek_event)) {
        GST_AVASSET_SRC_UNLOCK (self);
        break;
      }
      self->seek_event = gst_event_ref (event);
      gst_event_parse_seek (event, &rate, &format, &flags, &start_type,
          &start, &stop_type, &stop);

      if (rate < 0) {
        GST_WARNING ("Negative rates are not supported yet");
        GST_AVASSET_SRC_UNLOCK (self);
        res = FALSE;
        break;
      }

      gst_avasset_src_stop_reading (self);
      if (format != GST_FORMAT_TIME || start_type == GST_SEEK_TYPE_NONE) {
        GST_AVASSET_SRC_UNLOCK(self);
        res = FALSE;
        break;
      }
      if (stop_type == GST_SEEK_TYPE_NONE) {
        stop = GST_CLOCK_TIME_NONE;
      }
      gst_avasset_src_send_event (self, gst_event_new_flush_start ());
      [self->reader seekTo: start: stop: &error];
      newsegment = gst_event_new_new_segment (FALSE, rate, GST_FORMAT_TIME,
          start, stop, start);
      gst_avasset_src_send_event (self, gst_event_new_flush_stop ());
      gst_avasset_src_send_event (self, newsegment);

      if (error != NULL) {
        GST_ELEMENT_ERROR (self, RESOURCE, SEEK,
            ("AVAssetReader seek failed"), ("%s", error->message));
        g_error_free(error);
        res = FALSE;
      }
      gst_avasset_src_start_reading (self);
      GST_AVASSET_SRC_UNLOCK (self);
      gst_event_unref (event);
      break;
    }
    default:
      res = gst_pad_event_default (pad, event);
      break;
  }

  gst_object_unref (self);
  OBJC_CALLOUT_END ();
  return res;
}


static void
gst_avasset_src_read_data (GstAVAssetSrc *self, GstPad *pad,
    GstAVAssetReaderMediaType type)
{
  GstBuffer *buf;
  GstFlowReturn ret;
  GError *error;

  OBJC_CALLOUT_BEGIN ();

  GST_AVASSET_SRC_LOCK (self);
  if (self->state == GST_AVASSET_SRC_STATE_STOPPED) {
    GST_AVASSET_SRC_UNLOCK (self);
    goto exit;
  }

  buf = [self->reader nextBuffer:type:&error];
  GST_AVASSET_SRC_UNLOCK (self);

  if (buf == NULL) {
    if (error != NULL) {
      GST_ELEMENT_ERROR (self, RESOURCE, READ, ("Error reading next buffer"),
          ("%s", error->message));
      g_error_free (error);
      gst_avasset_src_stop_all (self);
      goto exit;
    }
    gst_pad_push_event (pad, gst_event_new_eos ());
    gst_avasset_src_stop_all (self);
    goto exit;
  }

  ret = gst_pad_push (pad, buf);
  if (GST_FLOW_IS_FATAL (ret)) {
    GST_ELEMENT_ERROR (self, STREAM, FAILED, NULL,
        ("Error pushing %s buffer on pad", MEDIA_TYPE_TO_STR (type)));
    gst_avasset_src_stop_all (self);
  }

exit:
  OBJC_CALLOUT_END ();
}

static void
gst_avasset_src_read_audio (GstAVAssetSrc *self)
{
  gst_avasset_src_read_data (self, self->audiopad,
      GST_AVASSET_READER_MEDIA_TYPE_AUDIO);
}

static void
gst_avasset_src_read_video (GstAVAssetSrc *self)
{
  gst_avasset_src_read_data (self, self->videopad,
      GST_AVASSET_READER_MEDIA_TYPE_VIDEO);
}

static gboolean
gst_avasset_src_start_task (GstAVAssetSrc *self, GstTask *task)
{
  GError *error = NULL;
  gboolean ret = TRUE;

  OBJC_CALLOUT_BEGIN ();

  [self->reader start: &error];
  if (error != NULL) {
    GST_ELEMENT_ERROR (self, RESOURCE, FAILED,
        ("AVAssetReader could not start reading"), ("%s", error->message));
    g_error_free (error);
    gst_avasset_src_stop_all (self);
    ret = FALSE;
    goto exit;
  }
  gst_task_start (task);

exit:
  OBJC_CALLOUT_END ();
  return ret;
}

static GstPadLinkReturn
gst_avasset_src_audio_pad_link (GstPad *pad, GstPad *peer)
{
  GstAVAssetSrc *self = GST_AVASSET_SRC (gst_pad_get_parent_element (pad));

  if (!gst_avasset_src_start_task (self, self->audio_task)) {
    return GST_PAD_LINK_REFUSED;
  }
  GST_DEBUG ("Started audio streaming task");
  g_object_unref (self);

  return GST_PAD_LINK_OK;
}

static GstPadLinkReturn
gst_avasset_src_video_pad_link (GstPad *pad, GstPad *peer)
{
  GstAVAssetSrc *self = GST_AVASSET_SRC (gst_pad_get_parent_element (pad));

  if (!gst_avasset_src_start_task (self, self->video_task)) {
    return GST_PAD_LINK_REFUSED;
  }
  GST_DEBUG ("Started video streaming task");
  g_object_unref (self);

  return GST_PAD_LINK_OK;
}

static gboolean
gst_avasset_src_send_event (GstAVAssetSrc *self, GstEvent *event)
{
  gboolean ret = TRUE;

  OBJC_CALLOUT_BEGIN ();

  if (AVASSET_READER_HAS_VIDEO (self)) {
    ret |= gst_pad_push_event (self->videopad, gst_event_ref (event));
  }
  if (AVASSET_READER_HAS_AUDIO (self)) {
    ret |= gst_pad_push_event (self->audiopad, gst_event_ref (event));
  }

  gst_event_unref (event);
  OBJC_CALLOUT_END ();
  return ret;
}

static void
gst_avasset_src_start (GstAVAssetSrc *self)
{
  OBJC_CALLOUT_BEGIN ();
  if (self->state == GST_AVASSET_SRC_STATE_STARTED) {
    goto exit;
  }

  GST_DEBUG_OBJECT (self, "Creating pads and starting reader");

  /* We call AVAssetReader's startReading when the pads are linked
   * and no outputs can be added afterwards, so the tracks must be
   * selected before adding any of the new pads */
  if (AVASSET_READER_HAS_AUDIO (self)) {
    [self->reader selectTrack: GST_AVASSET_READER_MEDIA_TYPE_AUDIO:
        self->selected_audio_track];
  }
  if (AVASSET_READER_HAS_VIDEO (self)) {
    [self->reader selectTrack: GST_AVASSET_READER_MEDIA_TYPE_VIDEO:
         self->selected_video_track];
  }

  if (AVASSET_READER_HAS_AUDIO (self)) {
    self->audiopad = gst_pad_new_from_static_template (&audio_factory, "audio");
    gst_pad_set_query_function (self->audiopad,
        (GstPadQueryFunction) gst_avasset_src_query);
    gst_pad_set_event_function(self->audiopad,
        (GstPadEventFunction) gst_avasset_src_event);
    gst_pad_set_link_function(self->audiopad,
        (GstPadLinkFunction) gst_avasset_src_audio_pad_link);
    gst_pad_set_active (self->audiopad, TRUE);
    gst_pad_set_caps (self->audiopad,
        [self->reader getCaps: GST_AVASSET_READER_MEDIA_TYPE_AUDIO]);
    gst_element_add_pad (GST_ELEMENT (self), self->audiopad);
  }
  if (AVASSET_READER_HAS_VIDEO (self)) {
    self->videopad = gst_pad_new_from_static_template (&video_factory, "video");
    gst_pad_set_query_function (self->videopad,
        (GstPadQueryFunction) gst_avasset_src_query);
    gst_pad_set_event_function(self->videopad,
        (GstPadEventFunction) gst_avasset_src_event);
    gst_pad_set_link_function(self->videopad,
        (GstPadLinkFunction) gst_avasset_src_video_pad_link);
    gst_pad_set_active (self->videopad, TRUE);
    gst_pad_set_caps (self->videopad,
        [self->reader getCaps: GST_AVASSET_READER_MEDIA_TYPE_VIDEO]);
    gst_element_add_pad (GST_ELEMENT (self), self->videopad);
  }
  gst_element_no_more_pads (GST_ELEMENT (self));

exit:
  OBJC_CALLOUT_END ();
}

static void
gst_avasset_src_stop (GstAVAssetSrc *self)
{
  gboolean has_audio, has_video;
  OBJC_CALLOUT_BEGIN();

  if (self->state == GST_AVASSET_SRC_STATE_STOPPED) {
    goto exit;
  }

  GST_DEBUG ("Stop reading");

  has_audio = AVASSET_READER_HAS_AUDIO (self);
  has_video = AVASSET_READER_HAS_VIDEO (self);
  [self->reader stop];

  if (has_audio) {
    gst_element_remove_pad (GST_ELEMENT (self), self->audiopad);
    gst_task_stop (self->audio_task);
  }
  if (has_video) {
    gst_element_remove_pad (GST_ELEMENT (self), self->videopad);
    gst_task_stop (self->video_task);
  }

exit:
  OBJC_CALLOUT_END ();
}

static void
gst_avasset_src_start_reading (GstAVAssetSrc *self)
{
  /* Only start the task here if we were playing before, otherwise wait until
   * the pad are linked to start the streaming task.
   */

  if (self->state < GST_AVASSET_SRC_STATE_STARTED) {
    return;
  }

  GST_DEBUG_OBJECT (self, "Start reading");

  if (GST_TASK_STATE (self->audio_task) == GST_TASK_PAUSED) {
    gst_task_start (self->audio_task);
  }
  if (GST_TASK_STATE (self->video_task) == GST_TASK_PAUSED) {
    gst_task_start (self->video_task);
  }
}

static void
gst_avasset_src_stop_reading (GstAVAssetSrc *self)
{
  if (self->state != GST_AVASSET_SRC_STATE_READING) {
      return;
  }

  GST_DEBUG_OBJECT (self, "Stop reading");

  if (GST_TASK_STATE (self->audio_task) == GST_TASK_STARTED) {
    gst_task_pause (self->audio_task);
  }
  if (GST_TASK_STATE (self->video_task) == GST_TASK_STARTED) {
    gst_task_pause (self->video_task);
  }
}

static void
gst_avasset_src_stop_all (GstAVAssetSrc *self)
{
  GST_AVASSET_SRC_LOCK (self);
  gst_avasset_src_stop_reading (self);
  gst_avasset_src_stop (self);
  self->state = GST_AVASSET_SRC_STATE_STOPPED;
  GST_AVASSET_SRC_UNLOCK (self);
}

static GQuark
gst_avasset_src_error_quark (void)
{
  static GQuark q;              /* 0 */

  if (G_UNLIKELY (q == 0)) {
      q = g_quark_from_static_string ("avasset-src-error-quark");
  }
  return q;
}

static GstURIType
gst_avasset_src_uri_get_type (void)
{
  return GST_URI_SRC;
}

static gchar **
gst_avasset_src_uri_get_protocols (void)
{
  static gchar *protocols[] = { (gchar *) "file",
      (gchar *) "ipod-library",  NULL };

  return protocols;
}

static const gchar *
gst_avasset_src_uri_get_uri (GstURIHandler * handler)
{
  GstAVAssetSrc *self = GST_AVASSET_SRC (handler);

  return self->uri;
}

static gboolean
gst_avasset_src_uri_set_uri (GstURIHandler * handler, const gchar * uri)
{
  GstAVAssetSrc *self = GST_AVASSET_SRC (handler);
  NSString *str;
  NSURL *url;
  AVAsset *asset;
  gchar *escaped_uri;
  gboolean ret = FALSE;

  OBJC_CALLOUT_BEGIN ();
  escaped_uri = g_uri_escape_string (uri, ":/", TRUE);
  str = [NSString stringWithUTF8String: escaped_uri];
  url = [[NSURL alloc] initWithString: str];
  asset = [AVAsset assetWithURL: url];
  g_free (escaped_uri);

  if (asset.playable) {
    ret = TRUE;
    if (self->uri) {
      g_free (self->uri);
    }
    self->uri = g_strdup (uri);
  }
  OBJC_CALLOUT_END ();
  return ret;
}

static void
gst_avasset_src_uri_handler_init (gpointer g_iface, gpointer iface_data)
{
  GstURIHandlerInterface *iface = (GstURIHandlerInterface *) g_iface;

  iface->get_type = gst_avasset_src_uri_get_type;
  iface->get_protocols = gst_avasset_src_uri_get_protocols;
  iface->get_uri = gst_avasset_src_uri_get_uri;
  iface->set_uri = gst_avasset_src_uri_set_uri;
}

@implementation GstAVAssetReader

@synthesize duration;
@synthesize position;

- (NSDictionary *) capsToAudioSettings
{
  gint samplerate, channels, depth, width;
  gboolean isFloat;
  GstStructure *s;

  if (!gst_caps_is_fixed (audio_caps))
    return NULL;

  s = gst_caps_get_structure (audio_caps, 0);
  isFloat = gst_structure_has_name (s, "audio/x-raw-float");
  gst_structure_get_int (s, "rate", &samplerate);
  gst_structure_get_int (s, "depth", &depth);
  gst_structure_get_int (s, "width", &width);
  gst_structure_get_int (s, "channels", &channels);

  return [NSDictionary dictionaryWithObjectsAndKeys:
      [NSNumber numberWithInt:kAudioFormatLinearPCM], AVFormatIDKey,
      [NSNumber numberWithFloat: samplerate], AVSampleRateKey,
      [NSNumber numberWithInt:channels], AVNumberOfChannelsKey,
      //[NSData dataWithBytes:&channelLayout length:sizeof(AudioChannelLayout)],
      //AVChannelLayoutKey,
      [NSNumber numberWithInt:depth], AVLinearPCMBitDepthKey,
      [NSNumber numberWithBool:isFloat],AVLinearPCMIsFloatKey,
      [NSNumber numberWithBool:NO], AVLinearPCMIsNonInterleaved,
      [NSNumber numberWithBool:NO], AVLinearPCMIsBigEndianKey,
      nil];
}

- (void) releaseReader
{
  [video_track release];
  [audio_track release];
  [video_tracks release];
  [audio_tracks release];
  [reader release];
}

- (void) initReader: (GError **) error
{
  NSError *nserror;

  reader = [[AVAssetReader alloc] initWithAsset:asset error:&nserror];
  if (nserror != NULL) {
    GST_ERROR ("Error initializing reader: %s",
        [nserror.description UTF8String]);
    *error = g_error_new (GST_AVASSET_SRC_ERROR, GST_AVASSET_ERROR_INIT, "%s",
        [nserror.description UTF8String]);
    [asset release];
    [reader release];
    return;
  }

  audio_tracks = [[asset tracksWithMediaType:AVMediaTypeAudio] retain];
  video_tracks = [[asset tracksWithMediaType:AVMediaTypeVideo] retain];
  reader.timeRange = CMTimeRangeMake(kCMTimeZero, asset.duration);
  GST_INFO ("Found %d video tracks and %d audio tracks",
      [video_tracks count], [audio_tracks count]);
}

- (id) initWithURI:(gchar*)uri : (GError **)error;
{
  NSString *str;
  NSURL *url;
  gchar *escaped_uri;

  GST_INFO ("Initializing AVAssetReader with uri:%s", uri);
  *error = NULL;

  escaped_uri = g_uri_escape_string (uri, ":/", TRUE);
  str = [NSString stringWithUTF8String: escaped_uri];
  url = [[NSURL alloc] initWithString: str];
  asset = [[AVAsset assetWithURL: url] retain];
  g_free (escaped_uri);

  if (!asset.playable) {
    *error = g_error_new (GST_AVASSET_SRC_ERROR, GST_AVASSET_ERROR_NOT_PLAYABLE,
        "Media is not playable");
    [asset release];
    return nil;
  }

  selected_audio_track = -1;
  selected_video_track = -1;
  reading = FALSE;
  position = 0;
  duration = CMTIME_TO_GST_TIME (asset.duration);

  /* FIXME: use fixed caps here until we found a way to determine
   * the native audio format */
  audio_caps = gst_caps_from_string ("audio/x-raw-float, "
     "endianness = (int) 1234, signed = (boolean) TRUE, "
     "rate = (int) 44100, channels = (int) 2, "
     "width= (int) 32, depth = (int) 32");

  [self initReader: error];
  if (*error) {
    return nil;
  }

  self = [super init];
  return self;
}

- (bool) selectTrack: (GstAVAssetReaderMediaType) type : (gint) index
{
  NSArray *tracks;
  AVAssetTrack *track;
  AVAssetReaderOutput **output;
  NSDictionary *settings;
  NSString *mediaType;
  gint *selected_track;

  GST_INFO ("Selecting %s track %d", MEDIA_TYPE_TO_STR(type), index);

  if (type == GST_AVASSET_READER_MEDIA_TYPE_AUDIO) {
    mediaType = AVMediaTypeAudio;
    selected_track = &selected_audio_track;
    output = &audio_track;
    settings = [self capsToAudioSettings];
  } else if (type == GST_AVASSET_READER_MEDIA_TYPE_VIDEO) {
    mediaType = AVMediaTypeVideo;
    selected_track = &selected_video_track;
    output = &video_track;
    settings = [NSDictionary dictionaryWithObjectsAndKeys:
        [NSNumber numberWithInt:
        kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange],
        kCVPixelBufferPixelFormatTypeKey, nil];
  } else {
    return FALSE;
  }

  tracks = [asset tracksWithMediaType:mediaType];
  if ([tracks count] == 0 || [tracks count] < index + 1) {
    return FALSE;
  }

  track = [tracks objectAtIndex:index];
  *selected_track = index;
  *output  = [AVAssetReaderTrackOutput
      assetReaderTrackOutputWithTrack:track
      outputSettings:settings];
  [*output retain];
  [reader addOutput:*output];
  return TRUE;
}

- (void) start: (GError **)error
{
  if (reading)
    return;

  if (![reader startReading]) {
    *error = g_error_new (GST_AVASSET_SRC_ERROR, GST_AVASSET_ERROR_START,
        "%s", [reader.error.description UTF8String]);
    reading = FALSE;
    return;
  }
  reading = TRUE;
}

- (void) stop
{
  [self->reader cancelReading];
  reading = FALSE;
}

- (bool) hasMediaType: (GstAVAssetReaderMediaType) type
{
  if (type == GST_AVASSET_READER_MEDIA_TYPE_AUDIO) {
    return [audio_tracks count] != 0;
  }
  if (type == GST_AVASSET_READER_MEDIA_TYPE_VIDEO) {
    return [video_tracks count] != 0;
  }
  return FALSE;
}

- (void) seekTo: (guint64) startTS : (guint64) stopTS : (GError **) error
{
  CMTime startTime = kCMTimeZero, stopTime = kCMTimePositiveInfinity;

  if (startTS != GST_CLOCK_TIME_NONE) {
    startTime = CMTimeMake (startTS, GST_SECOND);
  }
  if (stopTS != GST_CLOCK_TIME_NONE) {
    stopTime = CMTimeMake (stopTS, GST_SECOND);
  }

  /* AVAssetReader needs to be recreated before changing the
   * timerange property */
  [self stop];
  [self releaseReader];
  [self initReader: error];
  if (*error) {
    return;
  }

  GST_DEBUG ("Seeking to start:%" GST_TIME_FORMAT " stop:%" GST_TIME_FORMAT,
      GST_TIME_ARGS(startTS), GST_TIME_ARGS(stopTS));

  reader.timeRange = CMTimeRangeMake(startTime, stopTime);
  [self selectTrack: GST_AVASSET_READER_MEDIA_TYPE_AUDIO:selected_audio_track];
  [self selectTrack: GST_AVASSET_READER_MEDIA_TYPE_VIDEO:selected_video_track];
  [self start: error];
}

- (GstBuffer *) nextBuffer: (GstAVAssetReaderMediaType) type : (GError **) error
{
  CMSampleBufferRef cmbuf;
  AVAssetReaderTrackOutput *areader = NULL;
  GstCaps *caps;
  GstBuffer *buf;
  CMTime dur, ts;

  GST_LOG ("Reading %s next buffer", MEDIA_TYPE_TO_STR (type));
  if (type == GST_AVASSET_READER_MEDIA_TYPE_AUDIO && audio_track != NULL) {
    areader = audio_track;
    caps = audio_caps;
  } else if (type == GST_AVASSET_READER_MEDIA_TYPE_VIDEO &&
      video_track != NULL) {
    areader = video_track;
    caps = video_caps;
  }

  if (areader == NULL) {
    return NULL;
  }

  *error = NULL;
  cmbuf = [areader copyNextSampleBuffer];
  if (cmbuf == NULL) {
    if (reader.error != NULL) {
      *error = g_error_new (GST_AVASSET_SRC_ERROR, GST_AVASSET_ERROR_READ,
          "%s", [reader.error.description UTF8String]);
    }
    /* EOS */
    return NULL;
  }

  buf = gst_core_media_buffer_new (cmbuf);
  dur = CMSampleBufferGetDuration (cmbuf);
  ts = CMSampleBufferGetPresentationTimeStamp (cmbuf);
  if (dur.value != 0) {
    GST_BUFFER_DURATION (buf) = CMTIME_TO_GST_TIME (dur);
  }
  GST_BUFFER_TIMESTAMP (buf) = CMTIME_TO_GST_TIME (ts);
  gst_buffer_set_caps (buf, caps);
  GST_LOG ("Copying next %s buffer ts:%" GST_TIME_FORMAT " dur:%"
      GST_TIME_FORMAT, MEDIA_TYPE_TO_STR (type),
      GST_TIME_ARGS(GST_BUFFER_TIMESTAMP (buf)),
      GST_TIME_ARGS(GST_BUFFER_DURATION (buf)));
  if (GST_BUFFER_TIMESTAMP (buf) > position) {
    position = GST_BUFFER_TIMESTAMP (buf);
  }
  return buf;
}

- (GstCaps *) getCaps: (GstAVAssetReaderMediaType) type
{
  GstCaps *caps = NULL;
  AVAssetTrack *track;

  if (type == GST_AVASSET_READER_MEDIA_TYPE_AUDIO) {
    caps = gst_caps_ref (audio_caps);
    GST_INFO ("Using audio caps: %" GST_PTR_FORMAT, caps);
  } else if (type == GST_AVASSET_READER_MEDIA_TYPE_VIDEO) {
    gint fr_n, fr_d;

    track = [video_tracks objectAtIndex: selected_video_track];
    gst_util_double_to_fraction(track.nominalFrameRate, &fr_n, &fr_d);
    caps = gst_caps_new_simple ("video/x-raw-yuv",
        "format", GST_TYPE_FOURCC, GST_MAKE_FOURCC ('N', 'V', '1', '2'),
        "width", G_TYPE_INT, (int) track.naturalSize.width,
        "height", G_TYPE_INT, (int) track.naturalSize.height,
        "framerate", GST_TYPE_FRACTION, fr_n, fr_d, NULL);
    GST_INFO ("Using video caps: %" GST_PTR_FORMAT, caps);
    video_caps = gst_caps_ref (caps);
  }

  return caps;
}

- (oneway void) release
{
  [asset release];

  [self releaseReader];

  if (audio_caps != NULL) {
    gst_caps_unref (audio_caps);
  }

  if (video_caps != NULL) {
    gst_caps_unref (audio_caps);
  }
}

@end