media/java/android/media/MediaMuxer.java - platform/frameworks/base - Git at Google

 /*
  * Copyright (C) 2013 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package android.media;

 import android.media.MediaCodec.BufferInfo;
 import dalvik.system.CloseGuard;

 import java.io.FileDescriptor;
 import java.io.IOException;
 import java.io.RandomAccessFile;
 import java.nio.ByteBuffer;
 import java.util.Map;

 /**
  * MediaMuxer facilitates muxing elementary streams. Currently only supports an
  * mp4 file as the output and at most one audio and/or one video elementary
  * stream.
  * <p>
  * It is generally used like this:
  *
  * <pre>
  * MediaMuxer muxer = new MediaMuxer("temp.mp4", OutputFormat.MUXER_OUTPUT_MPEG_4);
  * // More often, the MediaFormat will be retrieved from MediaCodec.getOutputFormat()
  * // or MediaExtractor.getTrackFormat().
  * MediaFormat audioFormat = new MediaFormat(...);
  * MediaFormat videoFormat = new MediaFormat(...);
  * int audioTrackIndex = muxer.addTrack(audioFormat);
  * int videoTrackIndex = muxer.addTrack(videoFormat);
  * ByteBuffer inputBuffer = ByteBuffer.allocate(bufferSize);
  * boolean finished = false;
  * BufferInfo bufferInfo = new BufferInfo();
  *
  * muxer.start();
  * while(!finished) {
  *   // getInputBuffer() will fill the inputBuffer with one frame of encoded
  *   // sample from either MediaCodec or MediaExtractor, set isAudioSample to
  *   // true when the sample is audio data, set up all the fields of bufferInfo,
  *   // and return true if there are no more samples.
  *   finished = getInputBuffer(inputBuffer, isAudioSample, bufferInfo);
  *   if (!finished) {
  *     int currentTrackIndex = isAudioSample ? audioTrackIndex : videoTrackIndex;
  *     muxer.writeSampleData(currentTrackIndex, inputBuffer, bufferInfo);
  *   }
  * };
  * muxer.stop();
  * muxer.release();
  * </pre>
  */

 final public class MediaMuxer {

     static {
         System.loadLibrary("media_jni");
     }

     /**
      * Defines the output format. These constants are used with constructor.
      */
     public static final class OutputFormat {
         /* Do not change these values without updating their counterparts
          * in include/media/stagefright/MediaMuxer.h!
          */
         private OutputFormat() {}
         /** MPEG4 media file format*/
         public static final int MUXER_OUTPUT_MPEG_4 = 0;
         public static final int MUXER_OUTPUT_WEBM   = 1;
     };

     // All the native functions are listed here.
     private static native long nativeSetup(FileDescriptor fd, int format);
     private static native void nativeRelease(long nativeObject);
     private static native void nativeStart(long nativeObject);
     private static native void nativeStop(long nativeObject);
     private static native int nativeAddTrack(long nativeObject, String[] keys,
             Object[] values);
     private static native void nativeSetOrientationHint(long nativeObject,
             int degrees);
     private static native void nativeSetLocation(long nativeObject, int latitude, int longitude);
     private static native void nativeWriteSampleData(long nativeObject,
             int trackIndex, ByteBuffer byteBuf,
             int offset, int size, long presentationTimeUs, int flags);

     // Muxer internal states.
     private static final int MUXER_STATE_UNINITIALIZED  = -1;
     private static final int MUXER_STATE_INITIALIZED    = 0;
     private static final int MUXER_STATE_STARTED        = 1;
     private static final int MUXER_STATE_STOPPED        = 2;

     private int mState = MUXER_STATE_UNINITIALIZED;

     private final CloseGuard mCloseGuard = CloseGuard.get();
     private int mLastTrackIndex = -1;

     private long mNativeObject;

     /**
      * Constructor.
      * Creates a media muxer that writes to the specified path.
      * @param path The path of the output media file.
      * @param format The format of the output media file.
      * @see android.media.MediaMuxer.OutputFormat
      * @throws IOException if failed to open the file for write
      */
     public MediaMuxer(String path, int format) throws IOException {
         if (path == null) {
             throw new IllegalArgumentException("path must not be null");
         }
         if (format != OutputFormat.MUXER_OUTPUT_MPEG_4 &&
                 format != OutputFormat.MUXER_OUTPUT_WEBM) {
             throw new IllegalArgumentException("format is invalid");
         }
         // Use RandomAccessFile so we can open the file with RW access;
         // RW access allows the native writer to memory map the output file.
         RandomAccessFile file = null;
         try {
             file = new RandomAccessFile(path, "rws");
             FileDescriptor fd = file.getFD();
             mNativeObject = nativeSetup(fd, format);
             mState = MUXER_STATE_INITIALIZED;
             mCloseGuard.open("release");
         } finally {
             if (file != null) {
                 file.close();
             }
         }
     }

     /**
      * Sets the orientation hint for output video playback.
      * <p>This method should be called before {@link #start}. Calling this
      * method will not rotate the video frame when muxer is generating the file,
      * but add a composition matrix containing the rotation angle in the output
      * video if the output format is
      * {@link OutputFormat#MUXER_OUTPUT_MPEG_4} so that a video player can
      * choose the proper orientation for playback. Note that some video players
      * may choose to ignore the composition matrix in a video during playback.
      * By default, the rotation degree is 0.</p>
      * @param degrees the angle to be rotated clockwise in degrees.
      * The supported angles are 0, 90, 180, and 270 degrees.
      */
     public void setOrientationHint(int degrees) {
         if (degrees != 0 && degrees != 90  && degrees != 180 && degrees != 270) {
             throw new IllegalArgumentException("Unsupported angle: " + degrees);
         }
         if (mState == MUXER_STATE_INITIALIZED) {
             nativeSetOrientationHint(mNativeObject, degrees);
         } else {
             throw new IllegalStateException("Can't set rotation degrees due" +
                     " to wrong state.");
         }
     }

     /**
      * Set and store the geodata (latitude and longitude) in the output file.
      * This method should be called before {@link #start}. The geodata is stored
      * in udta box if the output format is
      * {@link OutputFormat#MUXER_OUTPUT_MPEG_4}, and is ignored for other output
      * formats. The geodata is stored according to ISO-6709 standard.
      *
      * @param latitude Latitude in degrees. Its value must be in the range [-90,
      * 90].
      * @param longitude Longitude in degrees. Its value must be in the range
      * [-180, 180].
      * @throws IllegalArgumentException If the given latitude or longitude is out
      * of range.
      * @throws IllegalStateException If this method is called after {@link #start}.
      */
     public void setLocation(float latitude, float longitude) {
         int latitudex10000  = (int) (latitude * 10000 + 0.5);
         int longitudex10000 = (int) (longitude * 10000 + 0.5);

         if (latitudex10000 > 900000 || latitudex10000 < -900000) {
             String msg = "Latitude: " + latitude + " out of range.";
             throw new IllegalArgumentException(msg);
         }
         if (longitudex10000 > 1800000 || longitudex10000 < -1800000) {
             String msg = "Longitude: " + longitude + " out of range";
             throw new IllegalArgumentException(msg);
         }

         if (mState == MUXER_STATE_INITIALIZED && mNativeObject != 0) {
             nativeSetLocation(mNativeObject, latitudex10000, longitudex10000);
         } else {
             throw new IllegalStateException("Can't set location due to wrong state.");
         }
     }

     /**
      * Starts the muxer.
      * <p>Make sure this is called after {@link #addTrack} and before
      * {@link #writeSampleData}.</p>
      */
     public void start() {
         if (mNativeObject == 0) {
             throw new IllegalStateException("Muxer has been released!");
         }
         if (mState == MUXER_STATE_INITIALIZED) {
             nativeStart(mNativeObject);
             mState = MUXER_STATE_STARTED;
         } else {
             throw new IllegalStateException("Can't start due to wrong state.");
         }
     }

     /**
      * Stops the muxer.
      * <p>Once the muxer stops, it can not be restarted.</p>
      */
     public void stop() {
         if (mState == MUXER_STATE_STARTED) {
             nativeStop(mNativeObject);
             mState = MUXER_STATE_STOPPED;
         } else {
             throw new IllegalStateException("Can't stop due to wrong state.");
         }
     }

     @Override
     protected void finalize() throws Throwable {
         try {
             if (mCloseGuard != null) {
                 mCloseGuard.warnIfOpen();
             }
             if (mNativeObject != 0) {
                 nativeRelease(mNativeObject);
                 mNativeObject = 0;
             }
         } finally {
             super.finalize();
         }
     }

     /**
      * Adds a track with the specified format.
      * @param format The media format for the track.
      * @return The track index for this newly added track, and it should be used
      * in the {@link #writeSampleData}.
      */
     public int addTrack(MediaFormat format) {
         if (format == null) {
             throw new IllegalArgumentException("format must not be null.");
         }
         if (mState != MUXER_STATE_INITIALIZED) {
             throw new IllegalStateException("Muxer is not initialized.");
         }
         if (mNativeObject == 0) {
             throw new IllegalStateException("Muxer has been released!");
         }
         int trackIndex = -1;
         // Convert the MediaFormat into key-value pairs and send to the native.
         Map<String, Object> formatMap = format.getMap();

         String[] keys = null;
         Object[] values = null;
         int mapSize = formatMap.size();
         if (mapSize > 0) {
             keys = new String[mapSize];
             values = new Object[mapSize];
             int i = 0;
             for (Map.Entry<String, Object> entry : formatMap.entrySet()) {
                 keys[i] = entry.getKey();
                 values[i] = entry.getValue();
                 ++i;
             }
             trackIndex = nativeAddTrack(mNativeObject, keys, values);
         } else {
             throw new IllegalArgumentException("format must not be empty.");
         }

         // Track index number is expected to incremented as addTrack succeed.
         // However, if format is invalid, it will get a negative trackIndex.
         if (mLastTrackIndex >= trackIndex) {
             throw new IllegalArgumentException("Invalid format.");
         }
         mLastTrackIndex = trackIndex;
         return trackIndex;
     }

     /**
      * Writes an encoded sample into the muxer.
      * <p>The application needs to make sure that the samples are written into
      * the right tracks. Also, it needs to make sure the samples for each track
      * are written in chronological order (e.g. in the order they are provided
      * by the encoder.)</p>
      * @param byteBuf The encoded sample.
      * @param trackIndex The track index for this sample.
      * @param bufferInfo The buffer information related to this sample.
      * MediaMuxer uses the flags provided in {@link MediaCodec.BufferInfo},
      * to signal sync frames.
      */
     public void writeSampleData(int trackIndex, ByteBuffer byteBuf,
             BufferInfo bufferInfo) {
         if (trackIndex < 0 || trackIndex > mLastTrackIndex) {
             throw new IllegalArgumentException("trackIndex is invalid");
         }

         if (byteBuf == null) {
             throw new IllegalArgumentException("byteBuffer must not be null");
         }

         if (bufferInfo == null) {
             throw new IllegalArgumentException("bufferInfo must not be null");
         }
         if (bufferInfo.size < 0 || bufferInfo.offset < 0
                 || (bufferInfo.offset + bufferInfo.size) > byteBuf.capacity()
                 || bufferInfo.presentationTimeUs < 0) {
             throw new IllegalArgumentException("bufferInfo must specify a" +
                     " valid buffer offset, size and presentation time");
         }

         if (mNativeObject == 0) {
             throw new IllegalStateException("Muxer has been released!");
         }

         if (mState != MUXER_STATE_STARTED) {
             throw new IllegalStateException("Can't write, muxer is not started");
         }

         nativeWriteSampleData(mNativeObject, trackIndex, byteBuf,
                 bufferInfo.offset, bufferInfo.size,
                 bufferInfo.presentationTimeUs, bufferInfo.flags);
     }

     /**
      * Make sure you call this when you're done to free up any resources
      * instead of relying on the garbage collector to do this for you at
      * some point in the future.
      */
     public void release() {
         if (mState == MUXER_STATE_STARTED) {
             stop();
         }
         if (mNativeObject != 0) {
             nativeRelease(mNativeObject);
             mNativeObject = 0;
             mCloseGuard.close();
         }
         mState = MUXER_STATE_UNINITIALIZED;
     }
 }
	/*
	* Copyright (C) 2013 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package android.media;

	import android.media.MediaCodec.BufferInfo;
	import dalvik.system.CloseGuard;

	import java.io.FileDescriptor;
	import java.io.IOException;
	import java.io.RandomAccessFile;
	import java.nio.ByteBuffer;
	import java.util.Map;

	/**
	* MediaMuxer facilitates muxing elementary streams. Currently only supports an
	* mp4 file as the output and at most one audio and/or one video elementary
	* stream.
	* <p>
	* It is generally used like this:
	*
	* <pre>
	* MediaMuxer muxer = new MediaMuxer("temp.mp4", OutputFormat.MUXER_OUTPUT_MPEG_4);
	* // More often, the MediaFormat will be retrieved from MediaCodec.getOutputFormat()
	* // or MediaExtractor.getTrackFormat().
	* MediaFormat audioFormat = new MediaFormat(...);
	* MediaFormat videoFormat = new MediaFormat(...);
	* int audioTrackIndex = muxer.addTrack(audioFormat);
	* int videoTrackIndex = muxer.addTrack(videoFormat);
	* ByteBuffer inputBuffer = ByteBuffer.allocate(bufferSize);
	* boolean finished = false;
	* BufferInfo bufferInfo = new BufferInfo();
	*
	* muxer.start();
	* while(!finished) {
	* // getInputBuffer() will fill the inputBuffer with one frame of encoded
	* // sample from either MediaCodec or MediaExtractor, set isAudioSample to
	* // true when the sample is audio data, set up all the fields of bufferInfo,
	* // and return true if there are no more samples.
	* finished = getInputBuffer(inputBuffer, isAudioSample, bufferInfo);
	* if (!finished) {
	* int currentTrackIndex = isAudioSample ? audioTrackIndex : videoTrackIndex;
	* muxer.writeSampleData(currentTrackIndex, inputBuffer, bufferInfo);
	* }
	* };
	* muxer.stop();
	* muxer.release();
	* </pre>
	*/

	final public class MediaMuxer {

	static {
	System.loadLibrary("media_jni");
	}

	/**
	* Defines the output format. These constants are used with constructor.
	*/
	public static final class OutputFormat {
	/* Do not change these values without updating their counterparts
	* in include/media/stagefright/MediaMuxer.h!
	*/
	private OutputFormat() {}
	/** MPEG4 media file format*/
	public static final int MUXER_OUTPUT_MPEG_4 = 0;
	public static final int MUXER_OUTPUT_WEBM = 1;
	};

	// All the native functions are listed here.
	private static native long nativeSetup(FileDescriptor fd, int format);
	private static native void nativeRelease(long nativeObject);
	private static native void nativeStart(long nativeObject);
	private static native void nativeStop(long nativeObject);
	private static native int nativeAddTrack(long nativeObject, String[] keys,
	Object[] values);
	private static native void nativeSetOrientationHint(long nativeObject,
	int degrees);
	private static native void nativeSetLocation(long nativeObject, int latitude, int longitude);
	private static native void nativeWriteSampleData(long nativeObject,
	int trackIndex, ByteBuffer byteBuf,
	int offset, int size, long presentationTimeUs, int flags);

	// Muxer internal states.
	private static final int MUXER_STATE_UNINITIALIZED = -1;
	private static final int MUXER_STATE_INITIALIZED = 0;
	private static final int MUXER_STATE_STARTED = 1;
	private static final int MUXER_STATE_STOPPED = 2;

	private int mState = MUXER_STATE_UNINITIALIZED;

	private final CloseGuard mCloseGuard = CloseGuard.get();
	private int mLastTrackIndex = -1;

	private long mNativeObject;

	/**
	* Constructor.
	* Creates a media muxer that writes to the specified path.
	* @param path The path of the output media file.
	* @param format The format of the output media file.
	* @see android.media.MediaMuxer.OutputFormat
	* @throws IOException if failed to open the file for write
	*/
	public MediaMuxer(String path, int format) throws IOException {
	if (path == null) {
	throw new IllegalArgumentException("path must not be null");
	}
	if (format != OutputFormat.MUXER_OUTPUT_MPEG_4 &&
	format != OutputFormat.MUXER_OUTPUT_WEBM) {
	throw new IllegalArgumentException("format is invalid");
	}
	// Use RandomAccessFile so we can open the file with RW access;
	// RW access allows the native writer to memory map the output file.
	RandomAccessFile file = null;
	try {
	file = new RandomAccessFile(path, "rws");
	FileDescriptor fd = file.getFD();
	mNativeObject = nativeSetup(fd, format);
	mState = MUXER_STATE_INITIALIZED;
	mCloseGuard.open("release");
	} finally {
	if (file != null) {
	file.close();
	}
	}
	}

	/**
	* Sets the orientation hint for output video playback.
	* <p>This method should be called before {@link #start}. Calling this
	* method will not rotate the video frame when muxer is generating the file,
	* but add a composition matrix containing the rotation angle in the output
	* video if the output format is
	* {@link OutputFormat#MUXER_OUTPUT_MPEG_4} so that a video player can
	* choose the proper orientation for playback. Note that some video players
	* may choose to ignore the composition matrix in a video during playback.
	* By default, the rotation degree is 0.</p>
	* @param degrees the angle to be rotated clockwise in degrees.
	* The supported angles are 0, 90, 180, and 270 degrees.
	*/
	public void setOrientationHint(int degrees) {
	if (degrees != 0 && degrees != 90 && degrees != 180 && degrees != 270) {
	throw new IllegalArgumentException("Unsupported angle: " + degrees);
	}
	if (mState == MUXER_STATE_INITIALIZED) {
	nativeSetOrientationHint(mNativeObject, degrees);
	} else {
	throw new IllegalStateException("Can't set rotation degrees due" +
	" to wrong state.");
	}
	}

	/**
	* Set and store the geodata (latitude and longitude) in the output file.
	* This method should be called before {@link #start}. The geodata is stored
	* in udta box if the output format is
	* {@link OutputFormat#MUXER_OUTPUT_MPEG_4}, and is ignored for other output
	* formats. The geodata is stored according to ISO-6709 standard.
	*
	* @param latitude Latitude in degrees. Its value must be in the range [-90,
	* 90].
	* @param longitude Longitude in degrees. Its value must be in the range
	* [-180, 180].
	* @throws IllegalArgumentException If the given latitude or longitude is out
	* of range.
	* @throws IllegalStateException If this method is called after {@link #start}.
	*/
	public void setLocation(float latitude, float longitude) {
	int latitudex10000 = (int) (latitude * 10000 + 0.5);
	int longitudex10000 = (int) (longitude * 10000 + 0.5);

	if (latitudex10000 > 900000 \|\| latitudex10000 < -900000) {
	String msg = "Latitude: " + latitude + " out of range.";
	throw new IllegalArgumentException(msg);
	}
	if (longitudex10000 > 1800000 \|\| longitudex10000 < -1800000) {
	String msg = "Longitude: " + longitude + " out of range";
	throw new IllegalArgumentException(msg);
	}

	if (mState == MUXER_STATE_INITIALIZED && mNativeObject != 0) {
	nativeSetLocation(mNativeObject, latitudex10000, longitudex10000);
	} else {
	throw new IllegalStateException("Can't set location due to wrong state.");
	}
	}

	/**
	* Starts the muxer.
	* <p>Make sure this is called after {@link #addTrack} and before
	* {@link #writeSampleData}.</p>
	*/
	public void start() {
	if (mNativeObject == 0) {
	throw new IllegalStateException("Muxer has been released!");
	}
	if (mState == MUXER_STATE_INITIALIZED) {
	nativeStart(mNativeObject);
	mState = MUXER_STATE_STARTED;
	} else {
	throw new IllegalStateException("Can't start due to wrong state.");
	}
	}

	/**
	* Stops the muxer.
	* <p>Once the muxer stops, it can not be restarted.</p>
	*/
	public void stop() {
	if (mState == MUXER_STATE_STARTED) {
	nativeStop(mNativeObject);
	mState = MUXER_STATE_STOPPED;
	} else {
	throw new IllegalStateException("Can't stop due to wrong state.");
	}
	}

	@Override
	protected void finalize() throws Throwable {
	try {
	if (mCloseGuard != null) {
	mCloseGuard.warnIfOpen();
	}
	if (mNativeObject != 0) {
	nativeRelease(mNativeObject);
	mNativeObject = 0;
	}
	} finally {
	super.finalize();
	}
	}

	/**
	* Adds a track with the specified format.
	* @param format The media format for the track.
	* @return The track index for this newly added track, and it should be used
	* in the {@link #writeSampleData}.
	*/
	public int addTrack(MediaFormat format) {
	if (format == null) {
	throw new IllegalArgumentException("format must not be null.");
	}
	if (mState != MUXER_STATE_INITIALIZED) {
	throw new IllegalStateException("Muxer is not initialized.");
	}
	if (mNativeObject == 0) {
	throw new IllegalStateException("Muxer has been released!");
	}
	int trackIndex = -1;
	// Convert the MediaFormat into key-value pairs and send to the native.
	Map<String, Object> formatMap = format.getMap();

	String[] keys = null;
	Object[] values = null;
	int mapSize = formatMap.size();
	if (mapSize > 0) {
	keys = new String[mapSize];
	values = new Object[mapSize];
	int i = 0;
	for (Map.Entry<String, Object> entry : formatMap.entrySet()) {
	keys[i] = entry.getKey();
	values[i] = entry.getValue();
	++i;
	}
	trackIndex = nativeAddTrack(mNativeObject, keys, values);
	} else {
	throw new IllegalArgumentException("format must not be empty.");
	}

	// Track index number is expected to incremented as addTrack succeed.
	// However, if format is invalid, it will get a negative trackIndex.
	if (mLastTrackIndex >= trackIndex) {
	throw new IllegalArgumentException("Invalid format.");
	}
	mLastTrackIndex = trackIndex;
	return trackIndex;
	}

	/**
	* Writes an encoded sample into the muxer.
	* <p>The application needs to make sure that the samples are written into
	* the right tracks. Also, it needs to make sure the samples for each track
	* are written in chronological order (e.g. in the order they are provided
	* by the encoder.)</p>
	* @param byteBuf The encoded sample.
	* @param trackIndex The track index for this sample.
	* @param bufferInfo The buffer information related to this sample.
	* MediaMuxer uses the flags provided in {@link MediaCodec.BufferInfo},
	* to signal sync frames.
	*/
	public void writeSampleData(int trackIndex, ByteBuffer byteBuf,
	BufferInfo bufferInfo) {
	if (trackIndex < 0 \|\| trackIndex > mLastTrackIndex) {
	throw new IllegalArgumentException("trackIndex is invalid");
	}

	if (byteBuf == null) {
	throw new IllegalArgumentException("byteBuffer must not be null");
	}

	if (bufferInfo == null) {
	throw new IllegalArgumentException("bufferInfo must not be null");
	}
	if (bufferInfo.size < 0 \|\| bufferInfo.offset < 0
	\|\| (bufferInfo.offset + bufferInfo.size) > byteBuf.capacity()
	\|\| bufferInfo.presentationTimeUs < 0) {
	throw new IllegalArgumentException("bufferInfo must specify a" +
	" valid buffer offset, size and presentation time");
	}

	if (mNativeObject == 0) {
	throw new IllegalStateException("Muxer has been released!");
	}

	if (mState != MUXER_STATE_STARTED) {
	throw new IllegalStateException("Can't write, muxer is not started");
	}

	nativeWriteSampleData(mNativeObject, trackIndex, byteBuf,
	bufferInfo.offset, bufferInfo.size,
	bufferInfo.presentationTimeUs, bufferInfo.flags);
	}

	/**
	* Make sure you call this when you're done to free up any resources
	* instead of relying on the garbage collector to do this for you at
	* some point in the future.
	*/
	public void release() {
	if (mState == MUXER_STATE_STARTED) {
	stop();
	}
	if (mNativeObject != 0) {
	nativeRelease(mNativeObject);
	mNativeObject = 0;
	mCloseGuard.close();
	}
	mState = MUXER_STATE_UNINITIALIZED;
	}
	}