/* GStreamer interactive test for accurate seeking
 * Copyright (C) 2014 Tim-Philipp Müller <tim centricular 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., 51 Franklin St, Fifth Floor,
 * Boston, MA 02110-1301, USA.
 *
 * Based on python script by Kibeom Kim <kkb110@gmail.com>
 */
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif

#include <string.h>

#include <gst/gst.h>
#include <gst/base/base.h>
#include <gst/audio/audio.h>
#include <gst/app/app.h>

#define SAMPLE_FREQ 44100

static const guint8 *
_memmem (const guint8 * haystack, gsize hlen, const guint8 * needle, gsize nlen)
{
  const guint8 *p = haystack;
  int needle_first;
  gsize plen = hlen;

  if (!nlen)
    return NULL;

  needle_first = *(unsigned char *) needle;

  while (plen >= nlen && (p = memchr (p, needle_first, plen - nlen + 1))) {
    if (!memcmp (p, needle, nlen))
      return (guint8 *) p;

    p++;
    plen = hlen - (p - haystack);
  }

  return NULL;
}

static GstClockTime
sample_to_nanotime (guint sample)
{
  return (guint64) ((1.0 * sample * GST_SECOND / SAMPLE_FREQ) + 0.5);
}

static guint
nanotime_to_sample (GstClockTime nanotime)
{
  return gst_util_uint64_scale_round (nanotime, SAMPLE_FREQ, GST_SECOND);
}

static GstBuffer *
generate_test_data (guint N)
{
  gint16 *left, *right, *stereo;
  guint largeN, i, j;

  /* 32767 = (2 ** 15) - 1 */
  /* 32768 = (2 ** 15) */
  largeN = ((N + 32767) / 32768) * 32768;
  left = g_new0 (gint16, largeN);
  right = g_new0 (gint16, largeN);
  stereo = g_new0 (gint16, 2 * largeN);

  for (i = 0; i < (largeN / 32768); ++i) {
    gint c = 0;

    for (j = i * 32768; j < ((i + 1) * 32768); ++j) {
      left[j] = i;

      if (i % 2 == 0) {
        right[j] = c;
      } else {
        right[j] = 32767 - c;
      }
      ++c;
    }
  }

  /* could just fill stereo directly from the start, but keeping original code for now */
  for (i = 0; i < largeN; ++i) {
    stereo[(2 * i) + 0] = left[i];
    stereo[(2 * i) + 1] = right[i];
  }
  g_free (left);
  g_free (right);

  return gst_buffer_new_wrapped (stereo, 2 * largeN * sizeof (gint16));
}

static void
generate_test_sound (const gchar * fn, const gchar * launch_string,
    guint num_samples)
{
  GstElement *pipeline, *src, *parse, *enc_bin, *sink;
  GstFlowReturn flow;
  GstMessage *msg;
  GstBuffer *buf;
  GstCaps *caps;

  pipeline = gst_pipeline_new (NULL);

  src = gst_element_factory_make ("appsrc", NULL);

  caps = gst_caps_new_simple ("audio/x-raw",
      "format", G_TYPE_STRING, GST_AUDIO_NE (S16),
      "rate", G_TYPE_INT, SAMPLE_FREQ, "channels", G_TYPE_INT, 2,
      "layout", G_TYPE_STRING, "interleaved",
      "channel-mask", GST_TYPE_BITMASK, (guint64) 3, NULL);
  g_object_set (src, "caps", caps, "format", GST_FORMAT_TIME, NULL);
  gst_base_src_set_format (GST_BASE_SRC (src), GST_FORMAT_TIME);
  gst_caps_unref (caps);

  /* audioparse to put proper timestamps on buffers for us, without which
   * vorbisenc in particular is unhappy (or oggmux, rather) */
  parse = gst_element_factory_make ("audioparse", NULL);
  if (parse != NULL) {
    g_object_set (parse, "use-sink-caps", TRUE, NULL);
  } else {
    parse = gst_element_factory_make ("identity", NULL);
    g_warning ("audioparse element not available, vorbis/ogg might not work\n");
  }

  enc_bin = gst_parse_bin_from_description (launch_string, TRUE, NULL);

  sink = gst_element_factory_make ("filesink", NULL);
  g_object_set (sink, "location", fn, NULL);

  gst_bin_add_many (GST_BIN (pipeline), src, parse, enc_bin, sink, NULL);

  gst_element_link_many (src, parse, enc_bin, sink, NULL);

  gst_element_set_state (pipeline, GST_STATE_PLAYING);

  buf = generate_test_data (num_samples);
  flow = gst_app_src_push_buffer (GST_APP_SRC (src), buf);
  g_assert (flow == GST_FLOW_OK);

  gst_app_src_end_of_stream (GST_APP_SRC (src));

  /*g_print ("generating test sound %s, waiting for EOS..\n", fn); */

  msg = gst_bus_timed_pop_filtered (GST_ELEMENT_BUS (pipeline),
      GST_CLOCK_TIME_NONE, GST_MESSAGE_EOS | GST_MESSAGE_ERROR);

  g_assert (GST_MESSAGE_TYPE (msg) == GST_MESSAGE_EOS);
  gst_message_unref (msg);

  gst_element_set_state (pipeline, GST_STATE_NULL);
  gst_object_unref (pipeline);

  /* g_print ("Done %s\n", fn); */
}

static void
test_seek_FORMAT_TIME_by_sample (const gchar * fn, GList * seek_positions)
{
  GstElement *pipeline, *src, *sink;
  GstAdapter *adapter;
  GstSample *sample;
  GstCaps *caps;
  gconstpointer answer;
  guint answer_size;

  pipeline = gst_parse_launch ("filesrc name=src ! decodebin ! "
      "audioconvert dithering=0 ! appsink name=sink", NULL);

  src = gst_bin_get_by_name (GST_BIN (pipeline), "src");
  g_object_set (src, "location", fn, NULL);
  gst_object_unref (src);

  sink = gst_bin_get_by_name (GST_BIN (pipeline), "sink");
  caps = gst_caps_new_simple ("audio/x-raw",
      "format", G_TYPE_STRING, GST_AUDIO_NE (S16),
      "rate", G_TYPE_INT, SAMPLE_FREQ, "channels", G_TYPE_INT, 2, NULL);
  g_object_set (sink, "caps", caps, "sync", FALSE, NULL);
  gst_caps_unref (caps);

  gst_element_set_state (pipeline, GST_STATE_PLAYING);

  /* wait for preroll, so we can seek */
  gst_bus_timed_pop_filtered (GST_ELEMENT_BUS (pipeline), GST_CLOCK_TIME_NONE,
      GST_MESSAGE_ASYNC_DONE);

  /* first, read entire file to end */
  adapter = gst_adapter_new ();
  while ((sample = gst_app_sink_pull_sample (GST_APP_SINK (sink)))) {
    gst_adapter_push (adapter, gst_buffer_ref (gst_sample_get_buffer (sample)));
    gst_sample_unref (sample);
  }
  answer_size = gst_adapter_available (adapter);
  answer = gst_adapter_map (adapter, answer_size);
  /* g_print ("%s: read %u bytes\n", fn, answer_size); */

  g_print ("%10s\t%10s\t%10s\n", "requested", "sample per ts", "actual(data)");

  while (seek_positions != NULL) {
    gconstpointer found;
    GstMapInfo map;
    GstBuffer *buf;
    gboolean ret;
    guint actual_position, buffer_timestamp_position;
    guint seek_sample;

    seek_sample = GPOINTER_TO_UINT (seek_positions->data);

    ret = gst_element_seek_simple (pipeline, GST_FORMAT_TIME,
        GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_ACCURATE,
        sample_to_nanotime (seek_sample));

    g_assert (ret);

    sample = gst_app_sink_pull_sample (GST_APP_SINK (sink));

    buf = gst_sample_get_buffer (sample);
    gst_buffer_map (buf, &map, GST_MAP_READ);
    GST_MEMDUMP ("answer", answer, answer_size);
    GST_MEMDUMP ("buffer", map.data, map.size);
    found = _memmem (answer, answer_size, map.data, map.size);
    gst_buffer_unmap (buf, &map);

    g_assert (found != NULL);
    actual_position = ((goffset) ((guint8 *) found - (guint8 *) answer)) / 4;
    buffer_timestamp_position = nanotime_to_sample (GST_BUFFER_PTS (buf));
    g_print ("%10u\t%10u\t%10u\n", seek_sample, buffer_timestamp_position,
        actual_position);
    gst_sample_unref (sample);

    seek_positions = seek_positions->next;
  }

  gst_element_set_state (pipeline, GST_STATE_NULL);
  gst_object_unref (sink);
  gst_object_unref (pipeline);
  g_object_unref (adapter);
}

static GList *
create_test_samples (guint from, guint to, guint step)
{
  GQueue q = G_QUEUE_INIT;
  guint i;

  for (i = from; i < to; i += step)
    g_queue_push_tail (&q, GUINT_TO_POINTER (i));

  return q.head;
}

#define SECS 10

int
main (int argc, char **argv)
{
  GList *test_samples;

  gst_init (&argc, &argv);

  test_samples = create_test_samples (SAMPLE_FREQ, SAMPLE_FREQ * 2, 5000);

  g_print ("\nwav:\n");
  generate_test_sound ("test.wav", "wavenc", SAMPLE_FREQ * SECS);
  test_seek_FORMAT_TIME_by_sample ("test.wav", test_samples);

  g_print ("\nflac:\n");
  generate_test_sound ("test.flac", "flacenc", SAMPLE_FREQ * SECS);
  test_seek_FORMAT_TIME_by_sample ("test.flac", test_samples);

  g_print ("\nogg:\n");
  generate_test_sound ("test.ogg",
      "audioconvert dithering=0 ! vorbisenc quality=1 ! oggmux",
      SAMPLE_FREQ * SECS);
  test_seek_FORMAT_TIME_by_sample ("test.ogg", test_samples);

  g_print ("\nmp3:\n");
  generate_test_sound ("test.mp3", "lamemp3enc bitrate=320",
      SAMPLE_FREQ * SECS);
  test_seek_FORMAT_TIME_by_sample ("test.mp3", test_samples);

  g_list_free (test_samples);
  return 0;
}