#include "rdft.h"

#include "api/api.h"

#ifdef HAVE_FFMPEG

#include <libavcodec/avfft.h>

/* currently ffmpeg uses 16-byte alignment for all architectures. This

 * function should probably be replaced with something built-in to

 * ffmpeg eventually. E.g. bool av_aligned(void *p); */

#define FFMPEG_ALIGNMENT() 16

#define size_rank_ok(x) \

	/* 1d data */ \

	((x) == 1)

#define vector_rank_ok(x) \

	/* a single vector */ \

	((x) == 0)

#define nbits_ok(x) \

	/* limits imposed by ffmpeg */ \

	((_log2((x)) >= 4) && (_log2((x)) <= 16))

#define input_stride_ok(x) \

	/* in-place -> i/o strides must be 1, regardless of kind */ \

	((x) == 1)

#define output_stride_ok(x) \

	/* in-place -> i/o strides must be 1, regardless of kind */ \

	((x) == 1)

#define alignment_ok(i,o) \

	/* in-place r2c / c2r -> pointers are always swapped */ \

	aligned(&((i)[1]))

#define io_place_ok(i,o) \

	(i == o)

typedef struct {

	solver super;

} S;

typedef struct {

	plan_rdft super;

	rdft_kind kind;

	int sign;

	int n;     /* problem size */

	int m;     /* m = log2(n) */

	int k;     /* fftw kind */

	RDFTContext *s;

	FFTSample *x;

} P;

/* fftw / ffmpeg rdft mappings */

static int ffmpeg_ok(int fftwK) {

	int r = 0;

	// for some reason R2HC is showing up as 11 instead of 0

	if ( fftwK == 11 ) fftwK = 0;

	switch( fftwK ) {

	case FFTW_R2HC:

	case FFTW_HC2R:

		r = 1;

		break;

	default:

		break;

	};

	return r;

}

static int ffmpeg_kind( int fftwKind, int sign ) {

	int i, r = -1;

	struct map_s {

		int fftwK;

		int sign;

		int ffmpegK;

	};

	const struct map_s map[] = {

			{ FFTW_R2HC, FFTW_FORWARD, DFT_R2C },

			{ FFTW_R2HC, FFTW_BACKWARD, IDFT_R2C },

			{ FFTW_HC2R, FFTW_FORWARD, DFT_C2R },

			{ FFTW_HC2R, FFTW_BACKWARD, IDFT_C2R },

	};

	const int nmap = sizeof(map) / sizeof(map[0]);

	for(i=0;i<nmap;i++) {

		if ( fftwKind = map[i].fftwK && sign == map[i].sign ) {

			r = map[i].ffmpegK;

			break;

		}

	}

	return r;

}

static int fftw_kind( int ffmpegK )

{

	int i,r = -1;

	struct map_s {

		int ffmpegK;

		int fftwK;

	};

	const struct map_s map[] = {

			{ DFT_R2C, FFTW_R2HC },

			{ IDFT_R2C, FFTW_R2HC },

			{ DFT_C2R, FFTW_HC2R },

			{ IDFT_C2R, FFTW_HC2R },

	};

	const int nmap = sizeof(map) / sizeof(map[0]);

	for(i=0;i<nmap;i++) {

		if ( ffmpegK == map[i].ffmpegK ) {

			r = map[i].fftwK;

			break;

		}

	}

	return r;

}

static int fftw_sign( int ffmpegK )

{

	int i,r=0;

	struct map_s {

		int ffmpegK;

		int sign;

	};

	const struct map_s map[] = {

			{ DFT_R2C, FFTW_FORWARD },

			{ IDFT_R2C, FFTW_BACKWARD },

			{ DFT_C2R, FFTW_FORWARD },

			{ IDFT_C2R, FFTW_BACKWARD },

	};

	const int nmap = sizeof(map) / sizeof(map[0]);

	for(i=0;i<nmap;i++) {

		if ( ffmpegK == map[i].ffmpegK ) {

			r = map[i].sign;

			break;

		}

	}

	return r;

}

static int _log2(unsigned int n)

{

	unsigned int m = 0;

	for( m = 0; m < 32; m++ )

		if ( ((1<<m)^n) == 0 )

			break;

	return ( m == 32 ) ? -1 : m;

}

static void unextract_reim(P *ego, const problem_rdft *p)

{

	// for in-place r2c or c2r transforms, the pointers are always swapped

	ego->x = (FFTSample *) &(p->I[1]);

}

static int aligned(void * p)

{

	unsigned long p1 = (unsigned long)p;

	unsigned long p2 = p1 & ~(FFMPEG_ALIGNMENT()-1);

	return (p1 == p2);

}

static void apply(const plan *ego_, R *I, R *O)

{

	const P *ego = (const P *) ego_;

	av_rdft_calc(ego->s,ego->x);

}

static void awake(plan *ego_, enum wakefulness wakefulness)

{

	(void) ego_; /* UNUSED */

	(void) wakefulness; /* UNUSED */

}

static int applicable0(const problem *p_)

{

	const problem_rdft *p = (const problem_rdft *) p_;

	int m = _log2(p->sz->dims[0].n);

	return( 1

		&& size_rank_ok(p->sz->rnk)

		&& vector_rank_ok(p->vecsz->rnk)

		&& nbits_ok(p->sz->dims[0].n)

		&& input_stride_ok(p->sz->dims[0].is)

		&& output_stride_ok(p->sz->dims[0].os)

		&& io_place_ok(p->I,p->O)

		&& alignment_ok(p->I,p->O) );

}

static int applicable(const solver *ego, const problem *p_,

		const planner *plnr)

{

	UNUSED(ego);

	if (!applicable0(p_)) return 0;

	return 1;

}

static void destroy(plan *ego_)

{

	P *ego = (P *) ego_;

	if ( ego && ego->s ) {

		av_rdft_end(ego->s);

		ego->s = (RDFTContext *)0;

	}

}

static void print(const plan *ego_, printer *p)

{

	const P *ego = (const P *)ego_;

	p->print(p, "(rdft-ffmpeg-%D)",ego->n);

}

static plan *mkplan(const solver *ego, const problem *p_, planner *plnr)

{

	const problem_rdft *p = (const problem_rdft *) p_;

	RDFTContext *s;

	P *pln;

	int n, m, k, d;

	static const plan_adt padt = {

			X(rdft_solve), awake, print, destroy

	};

	if ( ! applicable(ego, p_, plnr) )

		return (plan *)0;

	pln = MKPLAN_RDFT(P, &padt, apply);

	if ( ! pln )

		return (plan *)0;

	pln->n = n = p->sz->dims[0].n;

	m = _log2(n);

	//pln->sign = xplan->sign;

	pln->kind = p->kind[0];

	k = ffmpeg_kind( p->kind[0], pln->sign );

	pln->s = av_rdft_init(m,k);

	if ( ! pln->s ) {

		X(ifree)(pln);

		return (plan *)0;

	}

	// XXX: leaving as zero for now, since it varies by architecture

	X(ops_zero)(& pln->super.super.ops);

	return &(pln->super.super);

}

static solver *mksolver(void)

{

	static const solver_adt sadt = { PROBLEM_RDFT, mkplan, 0 };

	S *slv = MKSOLVER(S, &sadt);

	return &(slv->super);

}

void X(rdft_ffmpeg_register)(planner *p)

{

	REGISTER_SOLVER(p, mksolver());

}

#endif /* HAVE_FFMPEG */