Initial check-in for xml-based encoder capabilities retrieval (c371194e) · Commits · e / os / android_frameworks_base

include/media/MediaProfiles.h

0 → 100644

+303 −0

Original line number	Diff line number	Diff line
		/*
		**
		** Copyright 2010, 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.
		*/

		#ifndef ANDROID_MEDIAPROFILES_H
		#define ANDROID_MEDIAPROFILES_H

		#include <utils/threads.h>
		#include <media/mediarecorder.h>

		namespace android {

		enum camcorder_quality {
		CAMCORDER_QUALITY_HIGH = 0,
		CAMCORDER_QUALITY_LOW = 1
		};

		enum video_decoder {
		VIDEO_DECODER_WMV,
		};

		enum audio_decoder {
		AUDIO_DECODER_WMA,
		};


		class MediaProfiles
		{
		public:

		/**
		* Returns the singleton instance for subsequence queries.
		* or NULL if error.
		*/
		static MediaProfiles* getInstance();

		/**
		* Returns the value for the given param name at the given quality level,
		* or -1 if error.
		*
		* Supported param name are:
		* file.format - output file format. see mediarecorder.h for details
		* codec.vid - video encoder. see mediarecorder.h for details.
		* codec.aud - audio encoder. see mediarecorder.h for details.
		* vid.width - video frame width
		* vid.height - video frame height
		* vid.fps - video frame rate
		* vid.bps - video bit rate
		* aud.bps - audio bit rate
		* aud.hz - audio sample rate
		* aud.ch - number of audio channels
		*/
		int getCamcorderProfileParamByName(const char *name, camcorder_quality quality) const;

		/**
		* Returns the output file formats supported.
		*/
		Vector<output_format> getOutputFileFormats() const;

		/**
		* Returns the video encoders supported.
		*/
		Vector<video_encoder> getVideoEncoders() const;

		/**
		* Returns the value for the given param name for the given video encoder
		* returned from getVideoEncoderByIndex or -1 if error.
		*
		* Supported param name are:
		* enc.vid.width.min - min video frame width
		* enc.vid.width.max - max video frame width
		* enc.vid.height.min - min video frame height
		* enc.vid.height.max - max video frame height
		* enc.vid.bps.min - min bit rate in bits per second
		* enc.vid.bps.max - max bit rate in bits per second
		* enc.vid.fps.min - min frame rate in frames per second
		* enc.vid.fps.max - max frame rate in frames per second
		*/
		int getVideoEncoderParamByName(const char *name, video_encoder codec) const;

		/**
		* Returns the audio encoders supported.
		*/
		Vector<audio_encoder> getAudioEncoders() const;

		/**
		* Returns the value for the given param name for the given audio encoder
		* returned from getAudioEncoderByIndex or -1 if error.
		*
		* Supported param name are:
		* enc.aud.ch.min - min number of channels
		* enc.aud.ch.max - max number of channels
		* enc.aud.bps.min - min bit rate in bits per second
		* enc.aud.bps.max - max bit rate in bits per second
		* enc.aud.hz.min - min sample rate in samples per second
		* enc.aud.hz.max - max sample rate in samples per second
		*/
		int getAudioEncoderParamByName(const char *name, audio_encoder codec) const;

		/**
		* Returns the video decoders supported.
		*/
		Vector<video_decoder> getVideoDecoders() const;

		/**
		* Returns the audio decoders supported.
		*/
		Vector<audio_decoder> getAudioDecoders() const;

		private:
		MediaProfiles& operator=(const MediaProfiles&); // Don't call me
		MediaProfiles(const MediaProfiles&); // Don't call me
		MediaProfiles() {} // Dummy default constructor
		~MediaProfiles(); // Don't delete me

		struct VideoCodec {
		VideoCodec(video_encoder codec, int bitRate, int frameWidth, int frameHeight, int frameRate)
		: mCodec(codec),
		mBitRate(bitRate),
		mFrameWidth(frameWidth),
		mFrameHeight(frameHeight),
		mFrameRate(frameRate) {}

		~VideoCodec() {}

		video_encoder mCodec;
		int mBitRate;
		int mFrameWidth;
		int mFrameHeight;
		int mFrameRate;
		};

		struct AudioCodec {
		AudioCodec(audio_encoder codec, int bitRate, int sampleRate, int channels)
		: mCodec(codec),
		mBitRate(bitRate),
		mSampleRate(sampleRate),
		mChannels(channels) {}

		~AudioCodec() {}

		audio_encoder mCodec;
		int mBitRate;
		int mSampleRate;
		int mChannels;
		};

		struct CamcorderProfile {
		CamcorderProfile()
		: mFileFormat(OUTPUT_FORMAT_THREE_GPP),
		mQuality(CAMCORDER_QUALITY_HIGH),
		mDuration(0),
		mVideoCodec(0),
		mAudioCodec(0) {}

		~CamcorderProfile() {
		delete mVideoCodec;
		delete mAudioCodec;
		}

		output_format mFileFormat;
		camcorder_quality mQuality;
		int mDuration;
		VideoCodec *mVideoCodec;
		AudioCodec *mAudioCodec;
		};

		struct VideoEncoderCap {
		// Ugly constructor
		VideoEncoderCap(video_encoder codec,
		int minBitRate, int maxBitRate,
		int minFrameWidth, int maxFrameWidth,
		int minFrameHeight, int maxFrameHeight,
		int minFrameRate, int maxFrameRate)
		: mCodec(codec),
		mMinBitRate(minBitRate), mMaxBitRate(maxBitRate),
		mMinFrameWidth(minFrameWidth), mMaxFrameWidth(maxFrameWidth),
		mMinFrameHeight(minFrameHeight), mMaxFrameHeight(maxFrameHeight),
		mMinFrameRate(minFrameRate), mMaxFrameRate(maxFrameRate) {}

		~VideoEncoderCap() {}

		video_encoder mCodec;
		int mMinBitRate, mMaxBitRate;
		int mMinFrameWidth, mMaxFrameWidth;
		int mMinFrameHeight, mMaxFrameHeight;
		int mMinFrameRate, mMaxFrameRate;
		};

		struct AudioEncoderCap {
		// Ugly constructor
		AudioEncoderCap(audio_encoder codec,
		int minBitRate, int maxBitRate,
		int minSampleRate, int maxSampleRate,
		int minChannels, int maxChannels)
		: mCodec(codec),
		mMinBitRate(minBitRate), mMaxBitRate(maxBitRate),
		mMinSampleRate(minSampleRate), mMaxSampleRate(maxSampleRate),
		mMinChannels(minChannels), mMaxChannels(maxChannels) {}

		~AudioEncoderCap() {}

		audio_encoder mCodec;
		int mMinBitRate, mMaxBitRate;
		int mMinSampleRate, mMaxSampleRate;
		int mMinChannels, mMaxChannels;
		};

		struct VideoDecoderCap {
		VideoDecoderCap(video_decoder codec): mCodec(codec) {}
		~VideoDecoderCap() {}

		video_decoder mCodec;
		};

		struct AudioDecoderCap {
		AudioDecoderCap(audio_decoder codec): mCodec(codec) {}
		~AudioDecoderCap() {}

		audio_decoder mCodec;
		};

		struct NameToTagMap {
		const char* name;
		int tag;
		};

		// Debug
		static void logVideoCodec(const VideoCodec& codec);
		static void logAudioCodec(const AudioCodec& codec);
		static void logVideoEncoderCap(const VideoEncoderCap& cap);
		static void logAudioEncoderCap(const AudioEncoderCap& cap);
		static void logVideoDecoderCap(const VideoDecoderCap& cap);
		static void logAudioDecoderCap(const AudioDecoderCap& cap);

		// If the xml configuration file does exist, use the settings
		// from the xml
		static MediaProfiles* createInstanceFromXmlFile(const char *xml);
		static output_format createEncoderOutputFileFormat(const char **atts);
		static VideoCodec* createVideoCodec(const char *atts, MediaProfiles profiles);
		static AudioCodec* createAudioCodec(const char *atts, MediaProfiles profiles);
		static AudioDecoderCap* createAudioDecoderCap(const char **atts);
		static VideoDecoderCap* createVideoDecoderCap(const char **atts);
		static VideoEncoderCap* createVideoEncoderCap(const char **atts);
		static AudioEncoderCap* createAudioEncoderCap(const char **atts);
		static CamcorderProfile* createCamcorderProfile(const char **atts);

		// Customized element tag handler for parsing the xml configuration file.
		static void startElementHandler(void userData, const char name, const char **atts);

		// If the xml configuration file does not exist, use hard-coded values
		static MediaProfiles* createDefaultInstance();
		static CamcorderProfile *createDefaultCamcorderLowProfile();
		static CamcorderProfile *createDefaultCamcorderHighProfile();
		static void createDefaultCamcorderProfiles(MediaProfiles *profiles);
		static void createDefaultVideoEncoders(MediaProfiles *profiles);
		static void createDefaultAudioEncoders(MediaProfiles *profiles);
		static void createDefaultVideoDecoders(MediaProfiles *profiles);
		static void createDefaultAudioDecoders(MediaProfiles *profiles);
		static void createDefaultEncoderOutputFileFormats(MediaProfiles *profiles);
		static VideoEncoderCap* createDefaultH263VideoEncoderCap();
		static VideoEncoderCap* createDefaultM4vVideoEncoderCap();
		static AudioEncoderCap* createDefaultAmrNBEncoderCap();

		static int findTagForName(const NameToTagMap map, size_t nMappings, const char name);

		// Mappings from name (for instance, codec name) to enum value
		static const NameToTagMap sVideoEncoderNameMap[];
		static const NameToTagMap sAudioEncoderNameMap[];
		static const NameToTagMap sFileFormatMap[];
		static const NameToTagMap sVideoDecoderNameMap[];
		static const NameToTagMap sAudioDecoderNameMap[];
		static const NameToTagMap sCamcorderQualityNameMap[];

		static bool sIsInitialized;
		static MediaProfiles *sInstance;
		static Mutex sLock;

		Vector<CamcorderProfile*> mCamcorderProfiles;
		Vector<AudioEncoderCap*> mAudioEncoders;
		Vector<VideoEncoderCap*> mVideoEncoders;
		Vector<AudioDecoderCap*> mAudioDecoders;
		Vector<VideoDecoderCap*> mVideoDecoders;
		Vector<output_format> mEncoderOutputFileFormats;
		};

		}; // namespace android

		#endif // ANDROID_MEDIAPROFILES_H

media/java/android/media/EncoderCapabilities.java

0 → 100644

+164 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2010 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 java.util.List;
		import java.util.ArrayList;
		import android.util.Log;

		/**
		* The EncoderCapabilities class is used to retrieve the
		* capabilities for different video and audio
		* encoders supported on a specific Android platform.
		* {@hide}
		*/
		public class EncoderCapabilities
		{
		private static final String TAG = "EncoderCapabilities";

		/**
		* The VideoEncoderCap class represents a video encoder's
		* supported parameter range in:
		*
		* <ul>
		* <li>Resolution: the frame size (width/height) in pixels;
		* <li>Bit rate: the compressed output bit rate in bits per second;
		* <li>Frame rate: the output number of frames per second.
		* </ul>
		*
		*/
		static public class VideoEncoderCap {
		// These are not modifiable externally, thus are public accessible
		public final int mCodec; // @see android.media.MediaRecorder.VideoEncoder
		public final int mMinBitRate, mMaxBitRate; // min and max bit rate (bps)
		public final int mMinFrameRate, mMaxFrameRate; // min and max frame rate (fps)
		public final int mMinFrameWidth, mMaxFrameWidth; // min and max frame width (pixel)
		public final int mMinFrameHeight, mMaxFrameHeight; // minn and max frame height (pixel)

		// Private constructor called by JNI
		private VideoEncoderCap(int codec,
		int minBitRate, int maxBitRate,
		int minFrameRate, int maxFrameRate,
		int minFrameWidth, int maxFrameWidth,
		int minFrameHeight, int maxFrameHeight) {
		mCodec = codec;
		mMinBitRate = minBitRate;
		mMaxBitRate = maxBitRate;
		mMinFrameRate = minFrameRate;
		mMaxFrameRate = maxFrameRate;
		mMinFrameWidth = minFrameWidth;
		mMaxFrameWidth = maxFrameWidth;
		mMinFrameHeight = minFrameHeight;
		mMaxFrameHeight = maxFrameHeight;
		}
		};

		/**
		* The AudioEncoderCap class represents an audio encoder's
		* parameter range in:
		*
		* <ul>
		* <li>Bit rate: the compressed output bit rate in bits per second;
		* <li>Sample rate: the sampling rate used for recording the audio in samples per second;
		* <li>Number of channels: the number of channels the audio is recorded.
		* </ul>
		*
		*/
		static public class AudioEncoderCap {
		// These are not modifiable externally, thus are public accessible
		public final int mCodec; // @see android.media.MediaRecorder.AudioEncoder
		public final int mMinChannels, mMaxChannels; // min and max number of channels
		public final int mMinSampleRate, mMaxSampleRate; // min and max sample rate (hz)
		public final int mMinBitRate, mMaxBitRate; // min and max bit rate (bps)

		// Private constructor called by JNI
		private AudioEncoderCap(int codec,
		int minBitRate, int maxBitRate,
		int minSampleRate, int maxSampleRate,
		int minChannels, int maxChannels) {
		mCodec = codec;
		mMinBitRate = minBitRate;
		mMaxBitRate = maxBitRate;
		mMinSampleRate = minSampleRate;
		mMaxSampleRate = maxSampleRate;
		mMinChannels = minChannels;
		mMaxChannels = maxChannels;
		}
		};

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

		/**
		* Returns the array of supported output file formats.
		* @see android.media.MediaRecorder.OutputFormat
		*/
		public static int[] getOutputFileFormats() {
		int nFormats = native_get_num_file_formats();
		if (nFormats == 0) return null;

		int[] formats = new int[nFormats];
		for (int i = 0; i < nFormats; ++i) {
		formats[i] = native_get_file_format(i);
		}
		return formats;
		}

		/**
		* Returns the capabilities of the supported video encoders.
		* @see android.media.EncoderCapabilities.VideoEncoderCap
		*/
		public static List<VideoEncoderCap> getVideoEncoders() {
		int nEncoders = native_get_num_video_encoders();
		if (nEncoders == 0) return null;

		List<VideoEncoderCap> encoderList = new ArrayList<VideoEncoderCap>();
		for (int i = 0; i < nEncoders; ++i) {
		encoderList.add(native_get_video_encoder_cap(i));
		}
		return encoderList;
		}

		/**
		* Returns the capabilities of the supported audio encoders.
		* @see android.media.EncoderCapabilities.AudioEncoderCap
		*/
		public static List<AudioEncoderCap> getAudioEncoders() {
		int nEncoders = native_get_num_audio_encoders();
		if (nEncoders == 0) return null;

		List<AudioEncoderCap> encoderList = new ArrayList<AudioEncoderCap>();
		for (int i = 0; i < nEncoders; ++i) {
		encoderList.add(native_get_audio_encoder_cap(i));
		}
		return encoderList;
		}


		private EncoderCapabilities() {} // Don't call me

		// Implemented by JNI
		private static native final void native_init();
		private static native final int native_get_num_file_formats();
		private static native final int native_get_file_format(int index);
		private static native final int native_get_num_video_encoders();
		private static native final VideoEncoderCap native_get_video_encoder_cap(int index);
		private static native final int native_get_num_audio_encoders();
		private static native final AudioEncoderCap native_get_audio_encoder_cap(int index);
		}

media/jni/Android.mk

+2 −1

Original line number	Diff line number	Diff line
		@@ -10,7 +10,8 @@ LOCAL_SRC_FILES:= \
		android_media_MediaRecorder.cpp \
		android_media_MediaScanner.cpp \
		android_media_MediaMetadataRetriever.cpp \
		android_media_ResampleInputStream.cpp
		android_media_ResampleInputStream.cpp \
		android_media_MediaProfiles.cpp

		LOCAL_SHARED_LIBRARIES := \
		libandroid_runtime \

media/jni/android_media_MediaPlayer.cpp

+6 −0

Original line number	Diff line number	Diff line
		@@ -739,6 +739,7 @@ extern int register_android_media_MediaMetadataRetriever(JNIEnv *env);
		extern int register_android_media_MediaRecorder(JNIEnv *env);
		extern int register_android_media_MediaScanner(JNIEnv *env);
		extern int register_android_media_ResampleInputStream(JNIEnv *env);
		extern int register_android_media_MediaProfiles(JNIEnv *env);

		#ifndef NO_OPENCORE
		extern int register_android_media_AmrInputStream(JNIEnv *env);
		@@ -787,6 +788,11 @@ jint JNI_OnLoad(JavaVM* vm, void* reserved)
		goto bail;
		}

		if (register_android_media_MediaProfiles(env) < 0) {
		LOGE("ERROR: MediaProfiles native registration failed");
		goto bail;
		}

		/* success -- return valid version number */
		result = JNI_VERSION_1_4;

media/jni/android_media_MediaProfiles.cpp

0 → 100644

+187 −0

File added.

Preview size limit exceeded, changes collapsed.