18db49a462
Fix indentation to be multiple of 4. Make it easier to search: sp< not sp < to "switch (...)" instead of "switch(...)" (also "if" and "while") Remove redundant blank line at start or EOF. Remove whitespace at end of line. Remove extra blank lines where they don't add value. Use git diff -b or -w to verify. Change-Id: I966b7ba852faa5474be6907fb212f5e267c2874e
519 lines
19 KiB
C++
519 lines
19 KiB
C++
/*
|
|
**
|
|
** 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_LIST_START = 0,
|
|
CAMCORDER_QUALITY_LOW = 0,
|
|
CAMCORDER_QUALITY_HIGH = 1,
|
|
CAMCORDER_QUALITY_QCIF = 2,
|
|
CAMCORDER_QUALITY_CIF = 3,
|
|
CAMCORDER_QUALITY_480P = 4,
|
|
CAMCORDER_QUALITY_720P = 5,
|
|
CAMCORDER_QUALITY_1080P = 6,
|
|
CAMCORDER_QUALITY_QVGA = 7,
|
|
CAMCORDER_QUALITY_LIST_END = 7,
|
|
|
|
CAMCORDER_QUALITY_TIME_LAPSE_LIST_START = 1000,
|
|
CAMCORDER_QUALITY_TIME_LAPSE_LOW = 1000,
|
|
CAMCORDER_QUALITY_TIME_LAPSE_HIGH = 1001,
|
|
CAMCORDER_QUALITY_TIME_LAPSE_QCIF = 1002,
|
|
CAMCORDER_QUALITY_TIME_LAPSE_CIF = 1003,
|
|
CAMCORDER_QUALITY_TIME_LAPSE_480P = 1004,
|
|
CAMCORDER_QUALITY_TIME_LAPSE_720P = 1005,
|
|
CAMCORDER_QUALITY_TIME_LAPSE_1080P = 1006,
|
|
CAMCORDER_QUALITY_TIME_LAPSE_QVGA = 1007,
|
|
CAMCORDER_QUALITY_TIME_LAPSE_LIST_END = 1007,
|
|
};
|
|
|
|
/**
|
|
* Set CIF as default maximum import and export resolution of video editor.
|
|
* The maximum import and export resolutions are platform specific,
|
|
* which should be defined in media_profiles.xml.
|
|
* Set default maximum prefetch YUV frames to 6, which means video editor can
|
|
* queue up to 6 YUV frames in the video encoder source.
|
|
* This value is used to limit the amount of memory used by video editor
|
|
* engine when the encoder consumes YUV frames at a lower speed
|
|
* than video editor engine produces.
|
|
*/
|
|
enum videoeditor_capability {
|
|
VIDEOEDITOR_DEFAULT_MAX_INPUT_FRAME_WIDTH = 352,
|
|
VIDEOEDITOR_DEFUALT_MAX_INPUT_FRAME_HEIGHT = 288,
|
|
VIDEOEDITOR_DEFAULT_MAX_OUTPUT_FRAME_WIDTH = 352,
|
|
VIDEOEDITOR_DEFUALT_MAX_OUTPUT_FRAME_HEIGHT = 288,
|
|
VIDEOEDITOR_DEFAULT_MAX_PREFETCH_YUV_FRAMES = 6
|
|
};
|
|
|
|
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 for the given camera at
|
|
* the given quality level, or -1 if error.
|
|
*
|
|
* Supported param name are:
|
|
* duration - the recording duration.
|
|
* file.format - output file format. see mediarecorder.h for details
|
|
* vid.codec - video encoder. see mediarecorder.h for details.
|
|
* aud.codec - 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, int cameraId,
|
|
camcorder_quality quality) const;
|
|
|
|
/**
|
|
* Returns true if a profile for the given camera at the given quality exists,
|
|
* or false if not.
|
|
*/
|
|
bool hasCamcorderProfile(int cameraId, 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 value for the given param name for the video editor cap
|
|
* param or -1 if error.
|
|
* Supported param name are:
|
|
* videoeditor.input.width.max - max input video frame width
|
|
* videoeditor.input.height.max - max input video frame height
|
|
* videoeditor.output.width.max - max output video frame width
|
|
* videoeditor.output.height.max - max output video frame height
|
|
* maxPrefetchYUVFrames - max prefetch YUV frames in video editor engine. This value is used
|
|
* to limit the memory consumption.
|
|
*/
|
|
int getVideoEditorCapParamByName(const char *name) const;
|
|
|
|
/**
|
|
* Returns the value for the given param name for the video editor export codec format
|
|
* param or -1 if error.
|
|
* Supported param name are:
|
|
* videoeditor.export.profile - export video profile
|
|
* videoeditor.export.level - export video level
|
|
* Supported param codec are:
|
|
* 1 for h263
|
|
* 2 for h264
|
|
* 3 for mpeg4
|
|
*/
|
|
int getVideoEditorExportParamByName(const char *name, int 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;
|
|
|
|
/**
|
|
* Returns the number of image encoding quality levels supported.
|
|
*/
|
|
Vector<int> getImageEncodingQualityLevels(int cameraId) const;
|
|
|
|
/**
|
|
* Returns the start time offset (in ms) for the given camera Id.
|
|
* If the given camera Id does not exist, -1 will be returned.
|
|
*/
|
|
int getStartTimeOffsetMs(int cameraId) const;
|
|
|
|
private:
|
|
enum {
|
|
// Camcorder profiles (high/low) and timelapse profiles (high/low)
|
|
kNumRequiredProfiles = 4,
|
|
};
|
|
|
|
MediaProfiles& operator=(const MediaProfiles&); // Don't call me
|
|
MediaProfiles(const MediaProfiles&); // Don't call me
|
|
MediaProfiles() { mVideoEditorCap = NULL; } // 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(const VideoCodec& copy) {
|
|
mCodec = copy.mCodec;
|
|
mBitRate = copy.mBitRate;
|
|
mFrameWidth = copy.mFrameWidth;
|
|
mFrameHeight = copy.mFrameHeight;
|
|
mFrameRate = copy.mFrameRate;
|
|
}
|
|
|
|
~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(const AudioCodec& copy) {
|
|
mCodec = copy.mCodec;
|
|
mBitRate = copy.mBitRate;
|
|
mSampleRate = copy.mSampleRate;
|
|
mChannels = copy.mChannels;
|
|
}
|
|
|
|
~AudioCodec() {}
|
|
|
|
audio_encoder mCodec;
|
|
int mBitRate;
|
|
int mSampleRate;
|
|
int mChannels;
|
|
};
|
|
|
|
struct CamcorderProfile {
|
|
CamcorderProfile()
|
|
: mCameraId(0),
|
|
mFileFormat(OUTPUT_FORMAT_THREE_GPP),
|
|
mQuality(CAMCORDER_QUALITY_HIGH),
|
|
mDuration(0),
|
|
mVideoCodec(0),
|
|
mAudioCodec(0) {}
|
|
|
|
CamcorderProfile(const CamcorderProfile& copy) {
|
|
mCameraId = copy.mCameraId;
|
|
mFileFormat = copy.mFileFormat;
|
|
mQuality = copy.mQuality;
|
|
mDuration = copy.mDuration;
|
|
mVideoCodec = new VideoCodec(*copy.mVideoCodec);
|
|
mAudioCodec = new AudioCodec(*copy.mAudioCodec);
|
|
}
|
|
|
|
~CamcorderProfile() {
|
|
delete mVideoCodec;
|
|
delete mAudioCodec;
|
|
}
|
|
|
|
int mCameraId;
|
|
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;
|
|
};
|
|
|
|
struct ImageEncodingQualityLevels {
|
|
int mCameraId;
|
|
Vector<int> mLevels;
|
|
};
|
|
struct ExportVideoProfile {
|
|
ExportVideoProfile(int codec, int profile, int level)
|
|
:mCodec(codec),mProfile(profile),mLevel(level) {}
|
|
~ExportVideoProfile() {}
|
|
int mCodec;
|
|
int mProfile;
|
|
int mLevel;
|
|
};
|
|
struct VideoEditorCap {
|
|
VideoEditorCap(int inFrameWidth, int inFrameHeight,
|
|
int outFrameWidth, int outFrameHeight, int frames)
|
|
: mMaxInputFrameWidth(inFrameWidth),
|
|
mMaxInputFrameHeight(inFrameHeight),
|
|
mMaxOutputFrameWidth(outFrameWidth),
|
|
mMaxOutputFrameHeight(outFrameHeight),
|
|
mMaxPrefetchYUVFrames(frames) {}
|
|
|
|
~VideoEditorCap() {}
|
|
|
|
int mMaxInputFrameWidth;
|
|
int mMaxInputFrameHeight;
|
|
int mMaxOutputFrameWidth;
|
|
int mMaxOutputFrameHeight;
|
|
int mMaxPrefetchYUVFrames;
|
|
};
|
|
|
|
int getCamcorderProfileIndex(int cameraId, camcorder_quality quality) const;
|
|
void initRequiredProfileRefs(const Vector<int>& cameraIds);
|
|
int getRequiredProfileRefIndex(int cameraId);
|
|
|
|
// 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);
|
|
static void logVideoEditorCap(const VideoEditorCap& 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 VideoEditorCap* createVideoEditorCap(
|
|
const char **atts, MediaProfiles *profiles);
|
|
static ExportVideoProfile* createExportVideoProfile(const char **atts);
|
|
|
|
static CamcorderProfile* createCamcorderProfile(
|
|
int cameraId, const char **atts, Vector<int>& cameraIds);
|
|
|
|
static int getCameraId(const char **atts);
|
|
|
|
void addStartTimeOffset(int cameraId, const char **atts);
|
|
|
|
ImageEncodingQualityLevels* findImageEncodingQualityLevels(int cameraId) const;
|
|
void addImageEncodingQualityLevel(int cameraId, 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 *createDefaultCamcorderQcifProfile(camcorder_quality quality);
|
|
static CamcorderProfile *createDefaultCamcorderCifProfile(camcorder_quality quality);
|
|
static void createDefaultCamcorderLowProfiles(
|
|
MediaProfiles::CamcorderProfile **lowProfile,
|
|
MediaProfiles::CamcorderProfile **lowSpecificProfile);
|
|
static void createDefaultCamcorderHighProfiles(
|
|
MediaProfiles::CamcorderProfile **highProfile,
|
|
MediaProfiles::CamcorderProfile **highSpecificProfile);
|
|
|
|
static CamcorderProfile *createDefaultCamcorderTimeLapseQcifProfile(camcorder_quality quality);
|
|
static CamcorderProfile *createDefaultCamcorderTimeLapse480pProfile(camcorder_quality quality);
|
|
static void createDefaultCamcorderTimeLapseLowProfiles(
|
|
MediaProfiles::CamcorderProfile **lowTimeLapseProfile,
|
|
MediaProfiles::CamcorderProfile **lowSpecificTimeLapseProfile);
|
|
static void createDefaultCamcorderTimeLapseHighProfiles(
|
|
MediaProfiles::CamcorderProfile **highTimeLapseProfile,
|
|
MediaProfiles::CamcorderProfile **highSpecificTimeLapseProfile);
|
|
|
|
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 void createDefaultImageEncodingQualityLevels(MediaProfiles *profiles);
|
|
static void createDefaultImageDecodingMaxMemory(MediaProfiles *profiles);
|
|
static void createDefaultVideoEditorCap(MediaProfiles *profiles);
|
|
static void createDefaultExportVideoProfiles(MediaProfiles *profiles);
|
|
|
|
static VideoEncoderCap* createDefaultH263VideoEncoderCap();
|
|
static VideoEncoderCap* createDefaultM4vVideoEncoderCap();
|
|
static AudioEncoderCap* createDefaultAmrNBEncoderCap();
|
|
|
|
static int findTagForName(const NameToTagMap *map, size_t nMappings, const char *name);
|
|
|
|
/**
|
|
* Check on existing profiles with the following criteria:
|
|
* 1. Low quality profile must have the lowest video
|
|
* resolution product (width x height)
|
|
* 2. High quality profile must have the highest video
|
|
* resolution product (width x height)
|
|
*
|
|
* and add required low/high quality camcorder/timelapse
|
|
* profiles if they are not found. This allows to remove
|
|
* duplicate profile definitions in the media_profiles.xml
|
|
* file.
|
|
*/
|
|
void checkAndAddRequiredProfilesIfNecessary();
|
|
|
|
|
|
// 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;
|
|
int mCurrentCameraId;
|
|
|
|
Vector<CamcorderProfile*> mCamcorderProfiles;
|
|
Vector<AudioEncoderCap*> mAudioEncoders;
|
|
Vector<VideoEncoderCap*> mVideoEncoders;
|
|
Vector<AudioDecoderCap*> mAudioDecoders;
|
|
Vector<VideoDecoderCap*> mVideoDecoders;
|
|
Vector<output_format> mEncoderOutputFileFormats;
|
|
Vector<ImageEncodingQualityLevels *> mImageEncodingQualityLevels;
|
|
KeyedVector<int, int> mStartTimeOffsets;
|
|
|
|
typedef struct {
|
|
bool mHasRefProfile; // Refers to an existing profile
|
|
int mRefProfileIndex; // Reference profile index
|
|
int mResolutionProduct; // width x height
|
|
} RequiredProfileRefInfo; // Required low and high profiles
|
|
|
|
typedef struct {
|
|
RequiredProfileRefInfo mRefs[kNumRequiredProfiles];
|
|
int mCameraId;
|
|
} RequiredProfiles;
|
|
|
|
RequiredProfiles *mRequiredProfileRefs;
|
|
Vector<int> mCameraIds;
|
|
VideoEditorCap* mVideoEditorCap;
|
|
Vector<ExportVideoProfile*> mVideoEditorExportProfiles;
|
|
};
|
|
|
|
}; // namespace android
|
|
|
|
#endif // ANDROID_MEDIAPROFILES_H
|