#include "reodft.h"

#include "api/api.h"

#ifdef HAVE_FFMPEG

#include <libavcodec/avfft.h>

typedef struct {

	solver super;

} S;

typedef struct {

	plan_rdft super;

	int n;    /* problem size */

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

	int k; /* ffmpeg kind */

	DCTContext *s;

} P;

static int ffmpeg_kind( int fftwK ) {

	int r  = -1;

	switch( fftwK ) {

	// DCT

	case FFTW_REDFT00:

		r = DCT_I;

		break;

	case FFTW_REDFT01:

		r = DCT_III;

		break;

	case FFTW_REDFT10:

		r = DCT_II;

		break;

	case FFTW_REDFT11:

		// DCT_IV is not supported in ffmpeg

		break;

	// DST

	case FFTW_RODFT00:

		r = DST_I;

		break;

		// the remaining DST are not supported in ffmpeg

	default:

		break;

	}

	return r;

}

static int fftw_kind( int ffmpegK ) {

	int r = -1;

	switch( ffmpegK ) {

	// DCT

	case DCT_I:

		r = FFTW_REDFT00;

		break;

	case DCT_III:

		r = FFTW_REDFT01;

		break;

	case DCT_II:

		r = FFTW_REDFT10;

		break;

		// DCT_IV is not supported in ffmpeg

	// DST

	case DST_I:

		r = FFTW_RODFT00;

		break;

		// the remaining DST are not supported in ffmpeg

	default:

		break;

	}

	return r;

}

static int _log2(unsigned int n) {

	unsigned int m = 0;

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

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

			break;

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

}

static int aligned(void * p) {

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

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

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

	 */

	const unsigned int malloc_bytes = 16;

	unsigned long p1 = (unsigned long)p;

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

	return (p1 == p2);

}

static void apply(const plan *ego_, R *in, R *out)

{

	UNUSED(out);

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

	av_dct_calc(ego->s,(FFTSample *)in);

}

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_;

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

	int r;

	return ( 1

			/* 1D data */

			&& p->sz->rnk == 1

			/* a single vector */

			&& p->vecsz->rnk == 0

			/* power of two */

			&& m != -1

			/* min / max vector lengths (imposed by ffmpeg) */

			&& m >= 4 && m <= 14

			/* contiguous memory */

			&& p->sz->dims[0].is == 1

			&& p->sz->dims[0].os == 1

			// FIXME: out-of-place should also be fine, but requires additional

			// logic & allocation / deallocation of a temporary buffer

			/* in-place */

			&& p->I == p->O

			// FIXME: misaligned should also be fine, but requires additional

			// logic & allocation / deallocation of a temporary buffer

			/* check alignment */

			&& aligned(p->I) );

}

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_dct_end(ego->s);

		ego->s = (DCTContext *)0;

	}

}

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

{

	char *str;

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

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

}

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

{

	DCTContext *s;

	P *pln;

	const problem_rdft *p;

	plan *cld;

	R *buf;

	INT n;

	int m,k;

	opcnt ops;

	static const plan_adt padt = {

			X(rdft_solve), awake, print, destroy

	};

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

		return (plan *)0;

	p = (const problem_rdft *) p_;

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

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

	if ( ! pln )

		return (plan *)0;

	pln->n = n;

	pln->m = m = _log2(n);

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

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

	if ( ! s ) {

		X(ifree)(pln);

		return (plan *)0;

	}

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

	// architecture and also since the armv7 cycle timer is on the fritz

	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(reodft_ffmpeg_register)(planner *p)

{

	REGISTER_SOLVER(p, mksolver());

}

#endif /* HAVE_FFMPEG */