/*
 * GStreamer
 *
 * unit test for aacparse
 *
 * Copyright (C) 2008 Nokia Corporation. All rights reserved.
 *
 * Contact: Stefan Kost <stefan.kost@nokia.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.
 */

#include <gst/check/gstcheck.h>
#include <gst/app/gstappsink.h>
#include <gst/audio/audio.h>
#include "parser.h"

#define SRC_CAPS_TMPL   "audio/mpeg, parsed=(boolean)false, mpegversion=(int)1"
#define SINK_CAPS_TMPL  "audio/mpeg, parsed=(boolean)true, mpegversion=(int)1"

GstStaticPadTemplate sinktemplate = GST_STATIC_PAD_TEMPLATE ("sink",
    GST_PAD_SINK,
    GST_PAD_ALWAYS,
    GST_STATIC_CAPS (SINK_CAPS_TMPL)
    );

GstStaticPadTemplate srctemplate = GST_STATIC_PAD_TEMPLATE ("src",
    GST_PAD_SRC,
    GST_PAD_ALWAYS,
    GST_STATIC_CAPS (SRC_CAPS_TMPL)
    );

/* some data */
static guint8 mp3_frame[384] = {
  0xff, 0xfb, 0x94, 0xc4, 0xff, 0x83, 0xc0, 0x00,
  0x01, 0xa4, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00,
  0x34, 0x80, 0x00, 0x00, 0x04, 0x00,
};

static guint8 garbage_frame[] = {
  0xff, 0xff, 0xff, 0xff, 0xff
};


GST_START_TEST (test_parse_normal)
{
  gst_parser_test_normal (mp3_frame, sizeof (mp3_frame));
}

GST_END_TEST;


GST_START_TEST (test_parse_drain_single)
{
  gst_parser_test_drain_single (mp3_frame, sizeof (mp3_frame));
}

GST_END_TEST;


GST_START_TEST (test_parse_drain_garbage)
{
  gst_parser_test_drain_garbage (mp3_frame, sizeof (mp3_frame),
      garbage_frame, sizeof (garbage_frame));
}

GST_END_TEST;


GST_START_TEST (test_parse_split)
{
  gst_parser_test_split (mp3_frame, sizeof (mp3_frame));
}

GST_END_TEST;


GST_START_TEST (test_parse_skip_garbage)
{
  gst_parser_test_skip_garbage (mp3_frame, sizeof (mp3_frame),
      garbage_frame, sizeof (garbage_frame));
}

GST_END_TEST;


#define structure_get_int(s,f) \
    (g_value_get_int(gst_structure_get_value(s,f)))
#define fail_unless_structure_field_int_equals(s,field,num) \
    fail_unless_equals_int (structure_get_int(s,field), num)

GST_START_TEST (test_parse_detect_stream)
{
  GstStructure *s;
  GstCaps *caps;

  caps = gst_parser_test_get_output_caps (mp3_frame, sizeof (mp3_frame), NULL);

  fail_unless (caps != NULL);

  GST_LOG ("mpegaudio output caps: %" GST_PTR_FORMAT, caps);
  s = gst_caps_get_structure (caps, 0);
  fail_unless (gst_structure_has_name (s, "audio/mpeg"));
  fail_unless_structure_field_int_equals (s, "mpegversion", 1);
  fail_unless_structure_field_int_equals (s, "layer", 3);
  fail_unless_structure_field_int_equals (s, "channels", 1);
  fail_unless_structure_field_int_equals (s, "rate", 48000);

  gst_caps_unref (caps);
}

GST_END_TEST;


/* Gapless tests are performed using a test signal that contains 30 MPEG
 * frames, has padding samples at the beginning and at the end, a LAME
 * tag to inform about said padding samples, and a sample rate of 32 kHz
 * and 1 channel. The test signal is 1009ms long. setup_gapless_test_info()
 * fills the GaplessTestInfo struct with details about this test signal. */

typedef struct
{
  const gchar *filename;
  guint num_mpeg_frames;
  guint num_samples_per_frame;
  guint num_start_padding_samples;
  guint num_end_padding_samples;
  guint sample_rate;

  guint first_padded_end_frame;
  guint64 num_samples_with_padding;
  guint64 num_samples_without_padding;

  GstClockTime first_frame_duration;
  GstClockTime regular_frame_duration;
  GstClockTime total_duration_without_padding;

  GstElement *appsink;
  GstElement *parser;
} GaplessTestInfo;

static void
setup_gapless_test_info (GaplessTestInfo * info)
{
  info->filename = "sine-1009ms-1ch-32000hz-gapless-with-lame-tag.mp3";
  info->num_mpeg_frames = 31;
  info->num_samples_per_frame = 1152;   /* standard for MP3s */
  info->sample_rate = 32000;

  /* Note that these start and end padding figures are not exactly like
   * those that we get from the LAME tag. That's because that tag only
   * contains the _encoder_ delay & padding. In the figures below, the
   * _decoder_ delay is also factored in (529 samples). mpegaudioparse
   * does the same, so we have to apply it here. */
  info->num_start_padding_samples = 1105;
  info->num_end_padding_samples = 1167;

  /* In MP3s with LAME tags, the first frame is a frame made of Xing/LAME
   * metadata and dummy nullsamples (this is for backwards compatibility).
   * num_start_padding_samples defines how many padding samples are there
   * (this does not include the nullsamples from the first dummy frame).
   * Likewise, num_end_padding_samples defines how many padding samples
   * are there at the end of the MP3 stream.
   * There may be more padding samples than the size of one frame, meaning
   * that there may be frames that are made entirely of padding samples.
   * Such frames are output by mpegaudioparse, but their duration is set
   * to 0, and their PTS corresponds to the last valid PTS in the stream
   * (= the last PTS that is within the actual media data).
   * For this reason, we cannot just assume that the last frame is the
   * one containing padding - there may be more. So, calculate the number
   * of the first frame that contains padding sames from the _end_ of
   * the stream. We'll need that later for buffer PTS and duration checks. */
  info->first_padded_end_frame = (info->num_mpeg_frames - 1 -
      info->num_end_padding_samples / info->num_samples_per_frame);
  info->num_samples_with_padding = (info->num_mpeg_frames - 1) *
      info->num_samples_per_frame;
  info->num_samples_without_padding = info->num_samples_with_padding -
      info->num_start_padding_samples - info->num_end_padding_samples;

  /* The first frame (excluding the dummy frame at the beginning) will be
   * clipped due to the padding samples at the start of the stream, so we
   * have to calculate this separately. */
  info->first_frame_duration =
      gst_util_uint64_scale_int (info->num_samples_per_frame -
      info->num_start_padding_samples, GST_SECOND, info->sample_rate);
  /* Regular, unclipped MPEG frame duration. */
  info->regular_frame_duration =
      gst_util_uint64_scale_int (info->num_samples_per_frame, GST_SECOND,
      info->sample_rate);
  /* The total actual playtime duration. */
  info->total_duration_without_padding =
      gst_util_uint64_scale_int (info->num_samples_without_padding, GST_SECOND,
      info->sample_rate);
}

static void
check_parsed_mpeg_frame (GaplessTestInfo * info, guint frame_num)
{
  GstClockTime expected_pts = GST_CLOCK_TIME_NONE;
  GstClockTime expected_duration = GST_CLOCK_TIME_NONE;
  gboolean expect_audioclipmeta = FALSE;
  guint64 expected_audioclipmeta_start = 0;
  guint64 expected_audioclipmeta_end = 0;
  GstSample *sample;
  GstBuffer *buffer;
  GstAudioClippingMeta *audioclip_meta;

  GST_DEBUG ("checking frame %u", frame_num);

  /* This is called after the frame with the given number has been output by
   * mpegaudioparse. We can then pull that frame from appsink, and check its
   * PTS, duration, and audioclipmeta (if we expect it to be there). */

  if (frame_num == 0) {
    expected_pts = 0;
    expected_duration = 0;
    expect_audioclipmeta = FALSE;
  } else if (frame_num == 1) {
    /* First frame (excluding the dummy metadata frame at the beginning of
     * the MPEG stream that mpegaudioparse internally drops). This one will be
     * clipped due to the padding samples at the beginning, so we expect a
     * clipping meta to be there. Also, its duration will be smaller than that
     * of regular, unclipped frames. */

    expected_pts = 0;
    expected_duration = info->first_frame_duration;

    expect_audioclipmeta = TRUE;
    expected_audioclipmeta_start = info->num_start_padding_samples;
    expected_audioclipmeta_end = 0;
  } else if (frame_num > 1 && frame_num < info->first_padded_end_frame) {
    /* Regular, unclipped frame. */

    expected_pts = info->first_frame_duration + (frame_num - 2) *
        info->regular_frame_duration;
    expected_duration = info->regular_frame_duration;
  } else if (frame_num == info->first_padded_end_frame) {
    /* The first frame at the end with padding samples. This one will have
     * the last few valid samples, followed by the first padding samples. */

    guint64 num_valid_samples = (info->num_samples_with_padding -
        info->num_end_padding_samples) - (frame_num - 1) *
        info->num_samples_per_frame;
    guint64 num_padding_samples = info->num_samples_per_frame -
        num_valid_samples;

    expected_pts = info->first_frame_duration + (frame_num - 2) *
        info->regular_frame_duration;
    expected_duration = gst_util_uint64_scale_int (num_valid_samples,
        GST_SECOND, info->sample_rate);

    expect_audioclipmeta = TRUE;
    expected_audioclipmeta_start = 0;
    expected_audioclipmeta_end = num_padding_samples;
  } else {
    /* A fully clipped frame at the end of the stream. */

    expected_pts = info->total_duration_without_padding;
    expected_duration = 0;

    expect_audioclipmeta = TRUE;
    expected_audioclipmeta_start = 0;
    expected_audioclipmeta_end = info->num_samples_per_frame;
  }

  /* Pull the frame from appsink so we can check it. */

  sample = gst_app_sink_pull_sample (GST_APP_SINK (info->appsink));
  fail_if (sample == NULL);
  fail_unless (GST_IS_SAMPLE (sample));

  buffer = gst_sample_get_buffer (sample);
  fail_if (buffer == NULL);

  /* Verify the sample's PTS and duration. */
  fail_unless_equals_uint64 (GST_BUFFER_PTS (buffer), expected_pts);
  fail_unless_equals_uint64 (GST_BUFFER_DURATION (buffer), expected_duration);
  /* Check if there's audio clip metadata, and verify it if it exists. */
  if (expect_audioclipmeta) {
    audioclip_meta = gst_buffer_get_audio_clipping_meta (buffer);
    fail_if (audioclip_meta == NULL);
    fail_unless_equals_uint64 (audioclip_meta->start,
        expected_audioclipmeta_start);
    fail_unless_equals_uint64 (audioclip_meta->end, expected_audioclipmeta_end);
  }

  gst_sample_unref (sample);
}

GST_START_TEST (test_parse_gapless_and_skip_padding_samples)
{
  GstElement *source, *parser, *appsink, *pipeline;
  GstStateChangeReturn state_ret;
  guint frame_num;
  GaplessTestInfo info;

  setup_gapless_test_info (&info);

  pipeline = gst_pipeline_new (NULL);
  source = gst_element_factory_make ("filesrc", NULL);
  parser = gst_element_factory_make ("mpegaudioparse", NULL);
  appsink = gst_element_factory_make ("appsink", NULL);

  info.appsink = appsink;
  info.parser = parser;

  gst_bin_add_many (GST_BIN (pipeline), source, parser, appsink, NULL);
  gst_element_link_many (source, parser, appsink, NULL);

  {
    char *full_filename =
        g_build_filename (GST_TEST_FILES_PATH, info.filename, NULL);
    g_object_set (G_OBJECT (source), "location", full_filename, NULL);
    g_free (full_filename);
  }

  g_object_set (G_OBJECT (appsink), "async", FALSE, "sync", FALSE,
      "max-buffers", 1, "enable-last-sample", FALSE, "processing-deadline",
      G_MAXUINT64, NULL);

  state_ret = gst_element_set_state (pipeline, GST_STATE_PLAYING);

  fail_unless (state_ret != GST_STATE_CHANGE_FAILURE);

  if (state_ret == GST_STATE_CHANGE_ASYNC) {
    GST_LOG ("waiting for pipeline to reach PAUSED state");
    state_ret = gst_element_get_state (pipeline, NULL, NULL, -1);
    fail_unless_equals_int (state_ret, GST_STATE_CHANGE_SUCCESS);
  }

  /* Verify all frames from the test signal. */
  for (frame_num = 0; frame_num < info.num_mpeg_frames; ++frame_num)
    check_parsed_mpeg_frame (&info, frame_num);

  /* Check what duration is returned by a query. This duration must exclude
   * the padding samples. */
  {
    GstQuery *query;
    gint64 duration;
    GstFormat format;

    query = gst_query_new_duration (GST_FORMAT_TIME);
    fail_unless (gst_element_query (pipeline, query));

    gst_query_parse_duration (query, &format, &duration);
    fail_unless_equals_int (format, GST_FORMAT_TIME);
    fail_unless_equals_uint64 ((guint64) duration,
        info.total_duration_without_padding);

    gst_query_unref (query);
  }

  /* Seek tests: Here we seek to a certain position that corresponds to a
   * certain frame. Then we check if we indeed got that frame. */

  /* Seek back to the first frame. */
  {
    fail_unless_equals_int (gst_element_set_state (pipeline, GST_STATE_PAUSED),
        GST_STATE_CHANGE_SUCCESS);
    gst_element_seek_simple (pipeline, GST_FORMAT_TIME, GST_SEEK_FLAG_FLUSH |
        GST_SEEK_FLAG_KEY_UNIT, 0);
    fail_unless_equals_int (gst_element_set_state (pipeline, GST_STATE_PLAYING),
        GST_STATE_CHANGE_SUCCESS);

    check_parsed_mpeg_frame (&info, 1);
  }

  /* Seek to the second frame. */
  {
    fail_unless_equals_int (gst_element_set_state (pipeline, GST_STATE_PAUSED),
        GST_STATE_CHANGE_SUCCESS);
    gst_element_seek_simple (pipeline, GST_FORMAT_TIME, GST_SEEK_FLAG_FLUSH |
        GST_SEEK_FLAG_KEY_UNIT, info.first_frame_duration);
    fail_unless_equals_int (gst_element_set_state (pipeline, GST_STATE_PLAYING),
        GST_STATE_CHANGE_SUCCESS);

    check_parsed_mpeg_frame (&info, 2);
  }

  /* Seek to the last frame with valid samples (= the first frame with padding
   * samples at the end of the stream). */
  {
    GstClockTime pts = info.first_frame_duration +
        (info.first_padded_end_frame - 2) * info.regular_frame_duration;

    fail_unless_equals_int (gst_element_set_state (pipeline, GST_STATE_PAUSED),
        GST_STATE_CHANGE_SUCCESS);
    gst_element_seek_simple (pipeline, GST_FORMAT_TIME, GST_SEEK_FLAG_FLUSH |
        GST_SEEK_FLAG_KEY_UNIT, pts);
    fail_unless_equals_int (gst_element_set_state (pipeline, GST_STATE_PLAYING),
        GST_STATE_CHANGE_SUCCESS);

    check_parsed_mpeg_frame (&info, info.first_padded_end_frame);
  }

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

GST_END_TEST;


static Suite *
mpegaudioparse_suite (void)
{
  Suite *s = suite_create ("mpegaudioparse");
  TCase *tc_chain = tcase_create ("general");


  /* init test context */
  ctx_factory = "mpegaudioparse";
  ctx_sink_template = &sinktemplate;
  ctx_src_template = &srctemplate;

  suite_add_tcase (s, tc_chain);
  tcase_add_test (tc_chain, test_parse_normal);
  tcase_add_test (tc_chain, test_parse_drain_single);
  tcase_add_test (tc_chain, test_parse_drain_garbage);
  tcase_add_test (tc_chain, test_parse_split);
  tcase_add_test (tc_chain, test_parse_skip_garbage);
  tcase_add_test (tc_chain, test_parse_detect_stream);
  tcase_add_test (tc_chain, test_parse_gapless_and_skip_padding_samples);

  return s;
}


/*
 * TODO:
 *   - Both push- and pull-modes need to be tested
 *      * Pull-mode & EOS
 */
GST_CHECK_MAIN (mpegaudioparse);