/**
 * Copyright (c) 2011, The University of Southampton and the individual contributors.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without modification,
 * are permitted provided that the following conditions are met:
 *
 *   *  Redistributions of source code must retain the above copyright notice,
 *      this list of conditions and the following disclaimer.
 *
 *   *  Redistributions in binary form must reproduce the above copyright notice,
 *      this list of conditions and the following disclaimer in the documentation
 *      and/or other materials provided with the distribution.
 *
 *   *  Neither the name of the University of Southampton nor the names of its
 *      contributors may be used to endorse or promote products derived from this
 *      software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
 * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
/**
 *
 */
package org.openimaj.video.xuggle;

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.net.MalformedURLException;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.URL;
import java.util.concurrent.TimeUnit;

import org.apache.log4j.Logger;
import org.openimaj.audio.AudioFormat;
import org.openimaj.audio.AudioStream;
import org.openimaj.audio.SampleChunk;
import org.openimaj.audio.timecode.AudioTimecode;

import com.xuggle.mediatool.IMediaReader;
import com.xuggle.mediatool.MediaToolAdapter;
import com.xuggle.mediatool.ToolFactory;
import com.xuggle.mediatool.event.IAudioSamplesEvent;
import com.xuggle.xuggler.Global;
import com.xuggle.xuggler.IAudioSamples;
import com.xuggle.xuggler.ICodec;
import com.xuggle.xuggler.IContainer;
import com.xuggle.xuggler.IError;
import com.xuggle.xuggler.IStream;
import com.xuggle.xuggler.IStreamCoder;
import com.xuggle.xuggler.io.URLProtocolManager;

/**
 * A wrapper for the Xuggle audio decoding system into the OpenIMAJ audio
 * system.
 *
 * @author David Dupplaw (dpd@ecs.soton.ac.uk)
 * @created 8 Jun 2011
 *
 */
public class XuggleAudio extends AudioStream
{
        static Logger logger = Logger.getLogger(XuggleAudio.class);

        static {
                URLProtocolManager.getManager().registerFactory("jar", new JarURLProtocolHandlerFactory());
        }

        /** The reader used to read the video */
        private IMediaReader reader = null;

        /** The stream index that we'll be reading from */
        private int streamIndex = -1;

        /** The current sample chunk - note this is reused */
        private SampleChunk currentSamples = null;

        /** Whether we've read a complete chunk */
        private boolean chunkAvailable = false;

        /** The timecode of the current sample chunk */
        private final AudioTimecode currentTimecode = new AudioTimecode(0);

        /** The length of the media */
        private long length = -1;

        /** The URL being read */
        private final String url;

        /** Whether to loop the file */
        private final boolean loop;

        /**
         * Whether this class was constructed from a stream. Some functions are
         * unavailable
         */
        private boolean constructedFromStream = false;

        /**
         *
         *
         * @author David Dupplaw (dpd@ecs.soton.ac.uk)
         * @created 8 Jun 2011
         *
         */
        protected class ChunkGetter extends MediaToolAdapter
        {
                /**
                 * {@inheritDoc}
                 *
                 * @see com.xuggle.mediatool.MediaToolAdapter#onAudioSamples(com.xuggle.mediatool.event.IAudioSamplesEvent)
                 */
                @Override
                public void onAudioSamples(final IAudioSamplesEvent event)
                {
                        // Get the samples
                        final IAudioSamples aSamples = event.getAudioSamples();
                        final byte[] rawBytes = aSamples.getData().
                                        getByteArray(0, aSamples.getSize());
                        XuggleAudio.this.currentSamples.setSamples(rawBytes);

                        // Set the timecode of these samples
                        // double timestampMillisecs =
                        // rawBytes.length/format.getNumChannels() /
                        // format.getSampleRateKHz();
                        final long timestampMillisecs = TimeUnit.MILLISECONDS.convert(
                                        event.getTimeStamp().longValue(), event.getTimeUnit());

                        XuggleAudio.this.currentTimecode.setTimecodeInMilliseconds(
                                        timestampMillisecs);

                        XuggleAudio.this.currentSamples.setStartTimecode(
                                        XuggleAudio.this.currentTimecode);

                        XuggleAudio.this.currentSamples.getFormat().setNumChannels(
                                        XuggleAudio.this.getFormat().getNumChannels());

                        XuggleAudio.this.currentSamples.getFormat().setSigned(
                                        XuggleAudio.this.getFormat().isSigned());

                        XuggleAudio.this.currentSamples.getFormat().setBigEndian(
                                        XuggleAudio.this.getFormat().isBigEndian());

                        XuggleAudio.this.currentSamples.getFormat().setSampleRateKHz(
                                        XuggleAudio.this.getFormat().getSampleRateKHz());

                        XuggleAudio.this.chunkAvailable = true;
                }
        }

        /**
         * Default constructor that takes the file to read.
         *
         * @param file
         *            The file to read.
         */
        public XuggleAudio(final File file)
        {
                this(file.toURI().toString(), false);
        }

        /**
         * Default constructor that takes the file to read.
         *
         * @param file
         *            The file to read.
         * @param loop
         *            Whether to loop indefinitely
         */
        public XuggleAudio(final File file, final boolean loop)
        {
                this(file.toURI().toString(), loop);
        }

        /**
         * Default constructor that takes the location of a file to read. This can
         * either be a filename or a URL.
         *
         * @param u
         *            The URL of the file to read
         */
        public XuggleAudio(final URL u)
        {
                this(u.toString(), false);
        }

        /**
         * Default constructor that takes the location of a file to read. This can
         * either be a filename or a URL.
         *
         * @param u
         *            The URL of the file to read
         * @param loop
         *            Whether to loop indefinitely
         */
        public XuggleAudio(final URL u, final boolean loop)
        {
                this(u.toString(), loop);
        }

        /**
         * Default constructor that takes the location of a file to read. This can
         * either be a filename or a URL.
         *
         * @param url
         *            The URL of the file to read
         */
        public XuggleAudio(final String url)
        {
                this(url, false);
        }

        /**
         * Default constructor that takes the location of a file to read. This can
         * either be a filename or a URL. The second parameter determines whether
         * the file will loop indefinitely. If so, {@link #nextSampleChunk()} will
         * never return null; otherwise this method will return null at the end of
         * the video.
         *
         * @param u
         *            The URL of the file to read
         * @param loop
         *            Whether to loop indefinitely
         */
        public XuggleAudio(final String u, final boolean loop)
        {
                this.url = u;
                this.loop = loop;
                this.create(null);
        }

        /**
         * Construct a xuggle audio object from the stream.
         *
         * @param stream
         *            The stream
         */
        public XuggleAudio(final InputStream stream)
        {
                this.url = "stream://local";
                this.loop = false;
                this.constructedFromStream = true;
                this.create(stream);
        }

        /**
         * Create the Xuggler reader
         *
         * @param stream
         *            Can be NULL; else the stream to create from.
         */
        private void create(final InputStream stream)
        {
                // If the reader is already open, we'll close it first and
                // reinstantiate it.
                if (this.reader != null && this.reader.isOpen())
                {
                        this.reader.close();
                        this.reader = null;
                }

                // Check whether the string we have is a valid URI
                IContainer container = null;
                int openResult = 0;
                try
                {
                        // Create the container to read our audio file
                        container = IContainer.make();

                        // If we have a stream, we'll create from the stream...
                        if (stream != null)
                        {
                                openResult = container.open(stream, null, true, true);

                                if (openResult < 0)
                                        logger.info("XuggleAudio could not open InputStream to audio.");
                        }
                        // otherwise we'll use the URL in the class
                        else
                        {
                                final URI uri = new URI(this.url);

                                // If it's a valid URI, we'll try to open the container using
                                // the URI string.
                                openResult = container.open(uri.toString(),
                                                IContainer.Type.READ, null, true, true);

                                // If there was an error trying to open the container in this
                                // way,
                                // it may be that we have a resource URL (which ffmpeg doesn't
                                // understand), so we'll try opening an InputStream to the
                                // resource.
                                if (openResult < 0)
                                {
                                        logger.trace("URL " + this.url + " could not be opened by ffmpeg. " +
                                                        "Trying to open a stream to the URL instead.");
                                        final InputStream is = uri.toURL().openStream();
                                        openResult = container.open(is, null, true, true);

                                        if (openResult < 0)
                                        {
                                                logger.error("Error opening container. Error " + openResult +
                                                                " (" + IError.errorNumberToType(openResult).toString() + ")");
                                                return;
                                        }
                                }
                                else
                                        logger.info("Opened XuggleAudio stream ok: " + openResult);
                        }
                } catch (final URISyntaxException e2)
                {
                        e2.printStackTrace();
                        return;
                } catch (final MalformedURLException e)
                {
                        e.printStackTrace();
                        return;
                } catch (final IOException e)
                {
                        e.printStackTrace();
                        return;
                }

                // Set up a new reader using the container that reads the images.
                this.reader = ToolFactory.makeReader(container);
                this.reader.addListener(new ChunkGetter());
                this.reader.setCloseOnEofOnly(!this.loop);

                // Find the audio stream.
                IStream s = null;
                int i = 0;
                while (i < container.getNumStreams())
                {
                        s = container.getStream(i);
                        if (s != null &&
                                        s.getStreamCoder().getCodecType() == ICodec.Type.CODEC_TYPE_AUDIO)
                        {
                                // Save the stream index so that we only get frames from
                                // this stream in the FrameGetter
                                this.streamIndex = i;
                                break;
                        }
                        i++;
                }
                logger.info("Using audio stream " + this.streamIndex);

                if (container.getDuration() == Global.NO_PTS)
                        this.length = -1;
                else
                        this.length = (long) (s.getDuration() *
                                        s.getTimeBase().getDouble() * 1000d);

                // Get the coder for the audio stream
                final IStreamCoder aAudioCoder = container.
                                getStream(this.streamIndex).getStreamCoder();

                logger.info("Using stream code: " + aAudioCoder);

                // Create an audio format object suitable for the audio
                // samples from Xuggle files
                final AudioFormat af = new AudioFormat(
                                (int) IAudioSamples.findSampleBitDepth(aAudioCoder.getSampleFormat()),
                                aAudioCoder.getSampleRate() / 1000d,
                                aAudioCoder.getChannels());
                af.setSigned(true);
                af.setBigEndian(false);
                super.format = af;

                logger.info("XuggleAudio using audio format: " + af);

                this.currentSamples = new SampleChunk(af.clone());
        }

        // protected int retries = 0;
        // protected int maxRetries = 0;
        //
        // /**
        // * Set the maximum allowed number of retries in case of an error reading a
        // * packet. Only use this on live streams; if you do it on a file-based
        // * stream it might cause looping at the end of file.
        // *
        // * @param retries
        // * maximum number of retries
        // */
        // public void setMaxRetries(int retries) {
        // this.maxRetries = retries;
        // }

        /**
         * {@inheritDoc}
         *
         * @see org.openimaj.audio.AudioStream#nextSampleChunk()
         */
        @Override
        public SampleChunk nextSampleChunk()
        {
                try
                {
                        IError e = null;
                        while ((e = this.reader.readPacket()) == null && !this.chunkAvailable)
                                ;

                        if (!this.chunkAvailable) {
                                this.reader.close();
                                this.reader = null;
                                return null;
                        }

                        if (e != null)
                        {
                                this.reader.close();
                                this.reader = null;

                                // // We might be reading from a live stream & if we hit an
                                // error
                                // // we'll retry
                                // if (e != null && e.getType() != IError.Type.ERROR_EOF)
                                // {
                                // logger.error("Got audio demux error " + e.getDescription());
                                // this.create(null);
                                // this.retries++;
                                // }
                                // logger.info("Closing audio stream " + this.url);
                                return null;
                        }

                        this.chunkAvailable = false;
                        return this.currentSamples;
                } catch (final Exception e) {
                }

                return null;
        }

        /**
         * {@inheritDoc}
         *
         * @see org.openimaj.audio.AudioStream#reset()
         */
        @Override
        public void reset()
        {
                if (this.constructedFromStream)
                {
                        logger.info("Cannot reset a stream of audio.");
                        return;
                }

                if (this.reader == null || this.reader.getContainer() == null)
                        this.create(null);
                else
                        this.seek(0);
        }

        /**
         * {@inheritDoc}
         *
         * @see org.openimaj.audio.AudioStream#getLength()
         */
        @Override
        public long getLength()
        {
                return this.length;
        }

        /**
         * {@inheritDoc}
         *
         * @see org.openimaj.audio.AudioStream#seek(long)
         */
        @Override
        public void seek(final long timestamp)
        {
                if (this.constructedFromStream)
                {
                        logger.info("Cannot seek within a stream of audio.");
                        return;
                }

                if (this.reader == null || this.reader.getContainer() == null)
                        this.create(null);

                // Convert from milliseconds to stream timestamps
                final double timebase = this.reader.getContainer().getStream(
                                this.streamIndex).getTimeBase().getDouble();
                final long position = (long) (timestamp / timebase);

                final long min = Math.max(0, position - 100);
                final long max = position;

                // logger.info( "Timebase: "+timebase+" of a second second");
                // logger.info( "Position to seek to (timebase units): "+position
                // );
                // logger.info( "max: "+max+", min: "+min );

                final int i = this.reader.getContainer().seekKeyFrame(this.streamIndex,
                                min, position, max, 0);

                // Check for errors
                if (i < 0)
                        logger.error("Audio seek error (" + i + "): " + IError.errorNumberToType(i));
                else
                        this.nextSampleChunk();
        }

        /**
         * Close the audio stream.
         */
        public synchronized void close()
        {
                if (this.reader != null)
                {
                        synchronized (this.reader)
                        {
                                if (this.reader.isOpen())
                                {
                                        this.reader.close();
                                        this.reader = null;
                                }
                        }
                }
        }
}