/*

 * libiec61883 - Linux IEEE 1394 streaming media library.

 * Copyright (C) 2004 Kristian Hogsberg, Dan Dennedy, and Dan Maas.

 * This file written by Kristian Hogsberg.

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2.1 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

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser 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

 */

#ifdef HAVE_CONFIG_H

#include <config.h>

#endif

#include "iec61883.h"

#include "iec61883-private.h"

#include <netinet/in.h>

/* Integer fractional math.  When we transmit a 44k1Hz signal we must

 * send 5 41/80 samples per isochronous cycle, as these occur 8000

 * times a second.  Of course, we must send an integral number of

 * samples in a packet, so we use the integer math to alternate

 * between sending 5 and 6 samples per packet.

 */

static void

fraction_init(struct iec61883_fraction *f, int numerator, int denominator)

{

  f->integer = numerator / denominator;

  f->numerator = numerator % denominator;

  f->denominator = denominator;

}

static __inline__ void

fraction_add(struct iec61883_fraction *dst,

	     struct iec61883_fraction *src1, struct iec61883_fraction *src2)

{

  /* assert: src1->denominator == src2->denominator */

  int sum, denom;

  /* We use these two local variables to allow gcc to optimize

   * the division and the modulo into only one division. */

  sum = src1->numerator + src2->numerator;

  denom = src1->denominator;

  dst->integer = src1->integer + src2->integer + sum / denom;

  dst->numerator = sum % denom;

  dst->denominator = denom;

}

static __inline__ void

fraction_sub_int(struct iec61883_fraction *dst, struct iec61883_fraction *src, int integer)

{

  dst->integer = src->integer - integer;

  dst->numerator = src->numerator;

  dst->denominator = src->denominator;

}

static __inline__ int

fraction_floor(struct iec61883_fraction *frac)

{

  return frac->integer;

}

static __inline__ int

fraction_ceil(struct iec61883_fraction *frac)

{

  return frac->integer + (frac->numerator > 0 ? 1 : 0);

}

void

iec61883_cip_init(struct iec61883_cip *ptz, int format, int fdf,

		int rate, int dbs, int syt_interval)

{

  const int transfer_delay = 9000;

  ptz->rate = rate;

  ptz->cycle_count = transfer_delay / 3072;

  ptz->format = format;

  ptz->fdf = fdf;

  ptz->mode = IEC61883_MODE_BLOCKING_EMPTY;

  ptz->dbs = dbs;

  ptz->dbc = 0;

  ptz->syt_interval = syt_interval;

  fraction_init(&ptz->samples_per_cycle, ptz->rate, 8000);

  fraction_init(&ptz->ready_samples, 0, 8000);

  /* The ticks_per_syt_offset is initialized to the number of

   * ticks between syt_interval events.  The number of ticks per

   * second is 24.576e6, so the number of ticks between

   * syt_interval events is 24.576e6 * syt_interval / rate.

   */

  fraction_init(&ptz->ticks_per_syt_offset,

		24576000 * ptz->syt_interval, ptz->rate);

  fraction_init(&ptz->cycle_offset,

		(transfer_delay % 3072) * ptz->rate, ptz->rate);

}

void

iec61883_cip_resync(struct iec61883_cip *ptz, int cycle)

{

  const int transfer_delay = 9000;

  ptz->cycle_count = cycle + (transfer_delay / 3072);

  fraction_init(&ptz->cycle_offset,

		(transfer_delay % 3072) * ptz->rate, ptz->rate);

  fraction_init(&ptz->ready_samples, 0, 8000);

  ptz->dbc = 0;

}

void 

iec61883_cip_set_transmission_mode(struct iec61883_cip *ptz, int mode)

{

  ptz->mode = mode;

}

int 

iec61883_cip_get_max_packet_size(struct iec61883_cip *ptz)

{

  int max_nevents;

  if (ptz->mode == IEC61883_MODE_BLOCKING_EMPTY || ptz->mode == IEC61883_MODE_BLOCKING_NODATA)

    max_nevents = ptz->syt_interval;

  else

    max_nevents = fraction_ceil(&ptz->samples_per_cycle);

  return max_nevents * ptz->dbs * 4 + 8;

}

int

iec61883_cip_fill_header(raw1394handle_t handle, struct iec61883_cip *ptz,

		struct iec61883_packet *packet)

{

  struct iec61883_fraction next;

  int nevents, nevents_dbc, syt_index, syt;

  fraction_add(&next, &ptz->ready_samples, &ptz->samples_per_cycle);

  if (ptz->mode == IEC61883_MODE_BLOCKING_EMPTY ||

      ptz->mode == IEC61883_MODE_BLOCKING_NODATA) {

    if (fraction_floor(&next) >= ptz->syt_interval)

      nevents = ptz->syt_interval;

    else

      nevents = 0;

  }

  else

    nevents = fraction_floor(&next;;

  if (ptz->mode == IEC61883_MODE_BLOCKING_NODATA) {

    /* The DBC is incremented even with NO_DATA packets. */

    nevents_dbc = ptz->syt_interval;

  }

  else {

    nevents_dbc = nevents;

  }

  /* Now that we know how many events to put in the packet, update the

   * fraction ready_samples. */

  fraction_sub_int(&ptz->ready_samples, &next, nevents);

  /* Calculate synchronization timestamp (syt). First we

   * determine syt_index, that is, the index in the packet of

   * the sample for which the timestamp is valid. */

  syt_index = (ptz->syt_interval - ptz->dbc) & (ptz->syt_interval - 1);

  if (syt_index < nevents) {

    syt = ((ptz->cycle_count << 12) | fraction_floor(&ptz->cycle_offset)) & 0xffff;

    fraction_add(&ptz->cycle_offset, &ptz->cycle_offset,

		 &ptz->ticks_per_syt_offset);

    /* The cycle_count field is a 13 bits value that goes from 0 to 7999.

     * The cycle_offset field is a 12 bits value that goes from 0 to 3071. */

    ptz->cycle_count += ptz->cycle_offset.integer / 3072;

    ptz->cycle_count %= 8000;

    ptz->cycle_offset.integer %= 3072;

  }

  else

    syt = 0xffff;

  packet->eoh0 = 0;

  /* Our node ID can change after a bus reset, so it is best to fetch

   * our node ID for each packet. */

  packet->sid = raw1394_get_local_id( handle ) & 0x3f;

  packet->dbs = ptz->dbs;

  packet->fn = 0;

  packet->qpc = 0;

  packet->sph = 0;

  packet->reserved = 0;

  packet->dbc = ptz->dbc;

  packet->eoh1 = 2;

  packet->fmt = ptz->format;

  if ( nevents == 0 && ptz->mode == IEC61883_MODE_BLOCKING_NODATA ) {

    /* FDF code for packets containing dummy data. */

    packet->fdf = IEC61883_FDF_NODATA;

  }

  else {

    /* FDF code for non-blocking mode and for blocking mode with empty packets. */

    packet->fdf = ptz->fdf;

  }

  packet->syt = htons(syt);

  ptz->dbc += nevents_dbc;

  return nevents;

}