/* GStreamer

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

 *                    2000 Wim Taymans <wtay@chello.be>

 *                    2002 Thomas Vander Stichele <thomas@apestaart.org>

 *

 *

 * 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:gstutils

 * @short_description: Various utility functions

 *

 * When defining own plugins, use the GST_BOILERPLATE ease gobject creation.

 */

#include "gst_private.h"

#include <stdio.h>

#include <string.h>

#include "gstghostpad.h"

#include "gstutils.h"

#include "gsterror.h"

#include "gstinfo.h"

#include "gstparse.h"

#include "gst-i18n-lib.h"

#ifdef __SYMBIAN32__

#include <glib_global.h>

#include <gobject_global.h>

#endif

/**

 * gst_util_dump_mem:

 * @mem: a pointer to the memory to dump

 * @size: the size of the memory block to dump

 *

 * Dumps the memory block into a hex representation. Useful for debugging.

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

void

gst_util_dump_mem (const guchar * mem, guint size)

{

  guint i, j;

  GString *string = g_string_sized_new (50);

  GString *chars = g_string_sized_new (18);

  i = j = 0;

  while (i < size) {

    if (g_ascii_isprint (mem[i]))

      g_string_append_c (chars, mem[i]);

    else

      g_string_append_c (chars, '.');

    g_string_append_printf (string, "%02x ", mem[i]);

    j++;

    i++;

    if (j == 16 || i == size) {

      g_print ("%08x (%p): %-48.48s %-16.16s\n", i - j, mem + i - j,

          string->str, chars->str);

      g_string_set_size (string, 0);

      g_string_set_size (chars, 0);

      j = 0;

    }

  }

  g_string_free (string, TRUE);

  g_string_free (chars, TRUE);

}

/**

 * gst_util_set_value_from_string:

 * @value: the value to set

 * @value_str: the string to get the value from

 *

 * Converts the string to the type of the value and

 * sets the value with it.

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

void

gst_util_set_value_from_string (GValue * value, const gchar * value_str)

{

  g_return_if_fail (value != NULL);

  g_return_if_fail (value_str != NULL);

  GST_CAT_DEBUG (GST_CAT_PARAMS, "parsing '%s' to type %s", value_str,

      g_type_name (G_VALUE_TYPE (value)));

  }

}

/**

 * gst_util_set_object_arg:

 * @object: the object to set the argument of

 * @name: the name of the argument to set

 * @value: the string value to set

 *

 * Convertes the string value to the type of the objects argument and

 * sets the argument with it.

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

void

gst_util_set_object_arg (GObject * object, const gchar * name,

    const gchar * value)

{

  }

}

/* work around error C2520: conversion from unsigned __int64 to double

 * not implemented, use signed __int64

 *

 * These are implemented as functions because on some platforms a 64bit int to

 * double conversion is not defined/implemented.

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

gdouble

gst_util_guint64_to_gdouble (guint64 value)

{

  if (value & G_GINT64_CONSTANT (0x8000000000000000))

    return (gdouble) ((gint64) value) + (gdouble) 18446744073709551616.;

  else

    return (gdouble) ((gint64) value);

}

#ifdef __SYMBIAN32__

EXPORT_C

#endif

guint64

gst_util_gdouble_to_guint64 (gdouble value)

{

  if (value < (gdouble) 9223372036854775808.)   /* 1 << 63 */

    return ((guint64) ((gint64) value));

  value -= (gdouble) 18446744073709551616.;

  return ((guint64) ((gint64) value));

}

/* convenience struct for getting high and low uint32 parts of

 * a guint64 */

typedef union

{

  guint64 ll;

  struct

  {

#if G_BYTE_ORDER == G_BIG_ENDIAN

    guint32 high, low;

#else

    guint32 low, high;

#endif

  } l;

} GstUInt64;

/* based on Hacker's Delight p152 */

static guint64

gst_util_div128_64 (GstUInt64 c1, GstUInt64 c0, guint64 denom)

{

  GstUInt64 q1, q0, rhat;

  GstUInt64 v, cmp1, cmp2;

  guint s;

  v.ll = denom;

  /* count number of leading zeroes, we know they must be in the high

   * part of denom since denom > G_MAXUINT32. */

  s = v.l.high | (v.l.high >> 1);

  s |= (s >> 2);

  s |= (s >> 4);

  s |= (s >> 8);

  s = ~(s | (s >> 16));

  s = s - ((s >> 1) & 0x55555555);

  s = (s & 0x33333333) + ((s >> 2) & 0x33333333);

  s = (s + (s >> 4)) & 0x0f0f0f0f;

  s += (s >> 8);

  s = (s + (s >> 16)) & 0x3f;

  if (s > 0) {

    /* normalize divisor and dividend */

    v.ll <<= s;

    c1.ll = (c1.ll << s) | (c0.l.high >> (32 - s));

    c0.ll <<= s;

  }

  q1.ll = c1.ll / v.l.high;

  rhat.ll = c1.ll - q1.ll * v.l.high;

  cmp1.l.high = rhat.l.low;

  cmp1.l.low = c0.l.high;

  cmp2.ll = q1.ll * v.l.low;

  while (q1.l.high || cmp2.ll > cmp1.ll) {

    q1.ll--;

    rhat.ll += v.l.high;

    if (rhat.l.high)

      break;

    cmp1.l.high = rhat.l.low;

    cmp2.ll -= v.l.low;

  }

  c1.l.high = c1.l.low;

  c1.l.low = c0.l.high;

  c1.ll -= q1.ll * v.ll;

  q0.ll = c1.ll / v.l.high;

  rhat.ll = c1.ll - q0.ll * v.l.high;

  cmp1.l.high = rhat.l.low;

  cmp1.l.low = c0.l.low;

  cmp2.ll = q0.ll * v.l.low;

  while (q0.l.high || cmp2.ll > cmp1.ll) {

    q0.ll--;

    rhat.ll += v.l.high;

    if (rhat.l.high)

      break;

    cmp1.l.high = rhat.l.low;

    cmp2.ll -= v.l.low;

  }

  q0.l.high += q1.l.low;

  return q0.ll;

}

static guint64

{

  GstUInt64 a0, a1, b0, b1, c0, ct, c1, result;

  GstUInt64 v, n;

  /* prepare input */

  v.ll = val;

  n.ll = num;

  /* do 128 bits multiply

   *                   nh   nl

   *                *  vh   vl

   *                ----------

   * a0 =              vl * nl

   * a1 =         vl * nh

   * b0 =         vh * nl

   * b1 =  + vh * nh

   *       -------------------

   * c1,c0

   */

  a0.ll = (guint64) v.l.low * n.l.low;

  a1.ll = (guint64) v.l.low * n.l.high;

  b0.ll = (guint64) v.l.high * n.l.low;

  b1.ll = (guint64) v.l.high * n.l.high;

  /* and sum together with carry into 128 bits c1, c0 */

  c0.l.low = a0.l.low;

  ct.ll = (guint64) a0.l.high + a1.l.low + b0.l.low;

  c0.l.high = ct.l.low;

  c1.ll = (guint64) a1.l.high + b0.l.high + ct.l.high + b1.ll;

  /* if high bits bigger than denom, we overflow */

    goto overflow;

  /* shortcut for division by 1, c1.ll should be 0 because of the

   * overflow check above. */

  if (denom == 1)

    return c0.ll;

  /* and 128/64 bits division, result fits 64 bits */

  if (denom <= G_MAXUINT32) {

    guint32 den = (guint32) denom;

    /* easy case, (c1,c0)128/(den)32 division */

    c1.l.high %= den;

    c1.l.high = c1.ll % den;

    c1.l.low = c0.l.high;

    c0.l.high = c1.ll % den;

    result.l.high = c1.ll / den;

    result.l.low = c0.ll / den;

  } else {

    result.ll = gst_util_div128_64 (c1, c0, denom);

  }

  return result.ll;

overflow:

  {

    return G_MAXUINT64;

  }

}

/**

 * gst_util_uint64_scale:

 * @val: the number to scale

 * @num: the numerator of the scale ratio

 * @denom: the denominator of the scale ratio

 *

 * Scale @val by @num / @denom, trying to avoid overflows.

 *

 * This function can potentially be very slow if denom > G_MAXUINT32.

 *

 * Returns: @val * @num / @denom, trying to avoid overflows.

 * In the case of an overflow, this function returns G_MAXUINT64.

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

guint64

gst_util_uint64_scale (guint64 val, guint64 num, guint64 denom)

{

  g_return_val_if_fail (denom != 0, G_MAXUINT64);

    return 0;

    return val;

  /* if the denom is high, we need to do a 64 muldiv */

    goto do_int64;

  /* if num and denom are low we can do a 32 bit muldiv */

    goto do_int32;

  /* val and num are high, we need 64 muldiv */

    goto do_int64;

  /* val is low and num is high, we can swap them and do 32 muldiv */

do_int32:

do_int64:

  /* to the more heavy implementations... */

}

/**

 * gst_util_uint64_scale_int:

 * @val: guint64 (such as a #GstClockTime) to scale.

 * @num: numerator of the scale factor.

 * @denom: denominator of the scale factor.

 *

 * Scale a guint64 by a factor expressed as a fraction (num/denom), avoiding

 * overflows and loss of precision.

 *

 * @num and @denom must be positive integers. @denom cannot be 0.

 *

 * Returns: @val * @num / @denom, avoiding overflow and loss of precision.

 * In the case of an overflow, this function returns G_MAXUINT64.

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

guint64

gst_util_uint64_scale_int (guint64 val, gint num, gint denom)

{

  g_return_val_if_fail (denom > 0, G_MAXUINT64);

  g_return_val_if_fail (num >= 0, G_MAXUINT64);

    return 0;

    return val;

  if (val <= G_MAXUINT32)

    /* simple case */

    return val * num / denom;