/*
**
** 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.
*/
//#define LOG_NDEBUG 0
#define LOG_TAG "MediaProfiles"
#include <stdlib.h>
#include <utils/Log.h>
#include <utils/Vector.h>
#include <cutils/properties.h>
#include <expat.h>
#include <media/MediaProfiles.h>
#include <media/stagefright/foundation/ADebug.h>
#include <OMX_Video.h>
namespace android {
Mutex MediaProfiles::sLock;
bool MediaProfiles::sIsInitialized = false;
MediaProfiles *MediaProfiles::sInstance = NULL;
const MediaProfiles::NameToTagMap MediaProfiles::sVideoEncoderNameMap[] = {
{"h263", VIDEO_ENCODER_H263},
{"h264", VIDEO_ENCODER_H264},
{"m4v", VIDEO_ENCODER_MPEG_4_SP},
{"hevc", VIDEO_ENCODER_HEVC}
};
const MediaProfiles::NameToTagMap MediaProfiles::sAudioEncoderNameMap[] = {
{"amrnb", AUDIO_ENCODER_AMR_NB},
{"amrwb", AUDIO_ENCODER_AMR_WB},
{"aac", AUDIO_ENCODER_AAC},
{"heaac", AUDIO_ENCODER_HE_AAC},
{"aaceld", AUDIO_ENCODER_AAC_ELD}
};
const MediaProfiles::NameToTagMap MediaProfiles::sFileFormatMap[] = {
{"3gp", OUTPUT_FORMAT_THREE_GPP},
{"mp4", OUTPUT_FORMAT_MPEG_4}
};
const MediaProfiles::NameToTagMap MediaProfiles::sVideoDecoderNameMap[] = {
{"wmv", VIDEO_DECODER_WMV}
};
const MediaProfiles::NameToTagMap MediaProfiles::sAudioDecoderNameMap[] = {
{"wma", AUDIO_DECODER_WMA}
};
const MediaProfiles::NameToTagMap MediaProfiles::sCamcorderQualityNameMap[] = {
{"low", CAMCORDER_QUALITY_LOW},
{"high", CAMCORDER_QUALITY_HIGH},
{"qcif", CAMCORDER_QUALITY_QCIF},
{"cif", CAMCORDER_QUALITY_CIF},
{"480p", CAMCORDER_QUALITY_480P},
{"720p", CAMCORDER_QUALITY_720P},
{"1080p", CAMCORDER_QUALITY_1080P},
{"2160p", CAMCORDER_QUALITY_2160P},
{"qvga", CAMCORDER_QUALITY_QVGA},
{"timelapselow", CAMCORDER_QUALITY_TIME_LAPSE_LOW},
{"timelapsehigh", CAMCORDER_QUALITY_TIME_LAPSE_HIGH},
{"timelapseqcif", CAMCORDER_QUALITY_TIME_LAPSE_QCIF},
{"timelapsecif", CAMCORDER_QUALITY_TIME_LAPSE_CIF},
{"timelapse480p", CAMCORDER_QUALITY_TIME_LAPSE_480P},
{"timelapse720p", CAMCORDER_QUALITY_TIME_LAPSE_720P},
{"timelapse1080p", CAMCORDER_QUALITY_TIME_LAPSE_1080P},
{"timelapse2160p", CAMCORDER_QUALITY_TIME_LAPSE_2160P},
{"timelapseqvga", CAMCORDER_QUALITY_TIME_LAPSE_QVGA},
{"highspeedlow", CAMCORDER_QUALITY_HIGH_SPEED_LOW},
{"highspeedhigh", CAMCORDER_QUALITY_HIGH_SPEED_HIGH},
{"highspeed480p", CAMCORDER_QUALITY_HIGH_SPEED_480P},
{"highspeed720p", CAMCORDER_QUALITY_HIGH_SPEED_720P},
{"highspeed1080p", CAMCORDER_QUALITY_HIGH_SPEED_1080P},
{"highspeed2160p", CAMCORDER_QUALITY_HIGH_SPEED_2160P},
};
#if LOG_NDEBUG
#define UNUSED __unused
#else
#define UNUSED
#endif
/*static*/ void
MediaProfiles::logVideoCodec(const MediaProfiles::VideoCodec& codec UNUSED)
{
ALOGV("video codec:");
ALOGV("codec = %d", codec.mCodec);
ALOGV("bit rate: %d", codec.mBitRate);
ALOGV("frame width: %d", codec.mFrameWidth);
ALOGV("frame height: %d", codec.mFrameHeight);
ALOGV("frame rate: %d", codec.mFrameRate);
}
/*static*/ void
MediaProfiles::logAudioCodec(const MediaProfiles::AudioCodec& codec UNUSED)
{
ALOGV("audio codec:");
ALOGV("codec = %d", codec.mCodec);
ALOGV("bit rate: %d", codec.mBitRate);
ALOGV("sample rate: %d", codec.mSampleRate);
ALOGV("number of channels: %d", codec.mChannels);
}
/*static*/ void
MediaProfiles::logVideoEncoderCap(const MediaProfiles::VideoEncoderCap& cap UNUSED)
{
ALOGV("video encoder cap:");
ALOGV("codec = %d", cap.mCodec);
ALOGV("bit rate: min = %d and max = %d", cap.mMinBitRate, cap.mMaxBitRate);
ALOGV("frame width: min = %d and max = %d", cap.mMinFrameWidth, cap.mMaxFrameWidth);
ALOGV("frame height: min = %d and max = %d", cap.mMinFrameHeight, cap.mMaxFrameHeight);
ALOGV("frame rate: min = %d and max = %d", cap.mMinFrameRate, cap.mMaxFrameRate);
}
/*static*/ void
MediaProfiles::logAudioEncoderCap(const MediaProfiles::AudioEncoderCap& cap UNUSED)
{
ALOGV("audio encoder cap:");
ALOGV("codec = %d", cap.mCodec);
ALOGV("bit rate: min = %d and max = %d", cap.mMinBitRate, cap.mMaxBitRate);
ALOGV("sample rate: min = %d and max = %d", cap.mMinSampleRate, cap.mMaxSampleRate);
ALOGV("number of channels: min = %d and max = %d", cap.mMinChannels, cap.mMaxChannels);
}
/*static*/ void
MediaProfiles::logVideoDecoderCap(const MediaProfiles::VideoDecoderCap& cap UNUSED)
{
ALOGV("video decoder cap:");
ALOGV("codec = %d", cap.mCodec);
}
/*static*/ void
MediaProfiles::logAudioDecoderCap(const MediaProfiles::AudioDecoderCap& cap UNUSED)
{
ALOGV("audio codec cap:");
ALOGV("codec = %d", cap.mCodec);
}
/*static*/ int
MediaProfiles::findTagForName(const MediaProfiles::NameToTagMap *map, size_t nMappings,
const char *name)
{
int tag = -1;
for (size_t i = 0; i < nMappings; ++i) {
if (!strcmp(map[i].name, name)) {
tag = map[i].tag;
break;
}
}
return tag;
}
/*static*/ MediaProfiles::VideoCodec*
MediaProfiles::createVideoCodec(const char **atts, MediaProfiles *profiles)
{
CHECK(!strcmp("codec", atts[0]) &&
!strcmp("bitRate", atts[2]) &&
!strcmp("width", atts[4]) &&
!strcmp("height", atts[6]) &&
!strcmp("frameRate", atts[8]));
const size_t nMappings = sizeof(sVideoEncoderNameMap)/sizeof(sVideoEncoderNameMap[0]);
const int codec = findTagForName(sVideoEncoderNameMap, nMappings, atts[1]);
CHECK(codec != -1);
MediaProfiles::VideoCodec *videoCodec =
new MediaProfiles::VideoCodec(static_cast<video_encoder>(codec),
atoi(atts[3]), atoi(atts[5]), atoi(atts[7]), atoi(atts[9]));
logVideoCodec(*videoCodec);
size_t nCamcorderProfiles;
CHECK((nCamcorderProfiles = profiles->mCamcorderProfiles.size()) >= 1);
profiles->mCamcorderProfiles[nCamcorderProfiles - 1]->mVideoCodec = videoCodec;
return videoCodec;
}
/*static*/ MediaProfiles::AudioCodec*
MediaProfiles::createAudioCodec(const char **atts, MediaProfiles *profiles)
{
CHECK(!strcmp("codec", atts[0]) &&
!strcmp("bitRate", atts[2]) &&
!strcmp("sampleRate", atts[4]) &&
!strcmp("channels", atts[6]));
const size_t nMappings = sizeof(sAudioEncoderNameMap)/sizeof(sAudioEncoderNameMap[0]);
const int codec = findTagForName(sAudioEncoderNameMap, nMappings, atts[1]);
CHECK(codec != -1);
MediaProfiles::AudioCodec *audioCodec =
new MediaProfiles::AudioCodec(static_cast<audio_encoder>(codec),
atoi(atts[3]), atoi(atts[5]), atoi(atts[7]));
logAudioCodec(*audioCodec);
size_t nCamcorderProfiles;
CHECK((nCamcorderProfiles = profiles->mCamcorderProfiles.size()) >= 1);
profiles->mCamcorderProfiles[nCamcorderProfiles - 1]->mAudioCodec = audioCodec;
return audioCodec;
}
/*static*/ MediaProfiles::AudioDecoderCap*
MediaProfiles::createAudioDecoderCap(const char **atts)
{
CHECK(!strcmp("name", atts[0]) &&
!strcmp("enabled", atts[2]));
const size_t nMappings = sizeof(sAudioDecoderNameMap)/sizeof(sAudioDecoderNameMap[0]);
const int codec = findTagForName(sAudioDecoderNameMap, nMappings, atts[1]);
CHECK(codec != -1);
MediaProfiles::AudioDecoderCap *cap =
new MediaProfiles::AudioDecoderCap(static_cast<audio_decoder>(codec));
logAudioDecoderCap(*cap);
return cap;
}
/*static*/ MediaProfiles::VideoDecoderCap*
MediaProfiles::createVideoDecoderCap(const char **atts)
{
CHECK(!strcmp("name", atts[0]) &&
!strcmp("enabled", atts[2]));
const size_t nMappings = sizeof(sVideoDecoderNameMap)/sizeof(sVideoDecoderNameMap[0]);
const int codec = findTagForName(sVideoDecoderNameMap, nMappings, atts[1]);
CHECK(codec != -1);
MediaProfiles::VideoDecoderCap *cap =
new MediaProfiles::VideoDecoderCap(static_cast<video_decoder>(codec));
logVideoDecoderCap(*cap);
return cap;
}
/*static*/ MediaProfiles::VideoEncoderCap*
MediaProfiles::createVideoEncoderCap(const char **atts)
{
CHECK(!strcmp("name", atts[0]) &&
!strcmp("enabled", atts[2]) &&
!strcmp("minBitRate", atts[4]) &&
!strcmp("maxBitRate", atts[6]) &&
!strcmp("minFrameWidth", atts[8]) &&
!strcmp("maxFrameWidth", atts[10]) &&
!strcmp("minFrameHeight", atts[12]) &&
!strcmp("maxFrameHeight", atts[14]) &&
!strcmp("minFrameRate", atts[16]) &&
!strcmp("maxFrameRate", atts[18]));
const size_t nMappings = sizeof(sVideoEncoderNameMap)/sizeof(sVideoEncoderNameMap[0]);
const int codec = findTagForName(sVideoEncoderNameMap, nMappings, atts[1]);
CHECK(codec != -1);
MediaProfiles::VideoEncoderCap *cap =
new MediaProfiles::VideoEncoderCap(static_cast<video_encoder>(codec),
atoi(atts[5]), atoi(atts[7]), atoi(atts[9]), atoi(atts[11]), atoi(atts[13]),
atoi(atts[15]), atoi(atts[17]), atoi(atts[19]));
logVideoEncoderCap(*cap);
return cap;
}
/*static*/ MediaProfiles::AudioEncoderCap*
MediaProfiles::createAudioEncoderCap(const char **atts)
{
CHECK(!strcmp("name", atts[0]) &&
!strcmp("enabled", atts[2]) &&
!strcmp("minBitRate", atts[4]) &&
!strcmp("maxBitRate", atts[6]) &&
!strcmp("minSampleRate", atts[8]) &&
!strcmp("maxSampleRate", atts[10]) &&
!strcmp("minChannels", atts[12]) &&
!strcmp("maxChannels", atts[14]));
const size_t nMappings = sizeof(sAudioEncoderNameMap)/sizeof(sAudioEncoderNameMap[0]);
const int codec = findTagForName(sAudioEncoderNameMap, nMappings, atts[1]);
CHECK(codec != -1);
MediaProfiles::AudioEncoderCap *cap =
new MediaProfiles::AudioEncoderCap(static_cast<audio_encoder>(codec), atoi(atts[5]),
atoi(atts[7]), atoi(atts[9]), atoi(atts[11]), atoi(atts[13]), atoi(atts[15]));
logAudioEncoderCap(*cap);
return cap;
}
/*static*/ output_format
MediaProfiles::createEncoderOutputFileFormat(const char **atts)
{
CHECK(!strcmp("name", atts[0]));
const size_t nMappings =sizeof(sFileFormatMap)/sizeof(sFileFormatMap[0]);
const int format = findTagForName(sFileFormatMap, nMappings, atts[1]);
CHECK(format != -1);
return static_cast<output_format>(format);
}
static bool isCameraIdFound(int cameraId, const Vector<int>& cameraIds) {
for (int i = 0, n = cameraIds.size(); i < n; ++i) {
if (cameraId == cameraIds[i]) {
return true;
}
}
return false;
}
/*static*/ MediaProfiles::CamcorderProfile*
MediaProfiles::createCamcorderProfile(int cameraId, const char **atts, Vector<int>& cameraIds)
{
CHECK(!strcmp("quality", atts[0]) &&
!strcmp("fileFormat", atts[2]) &&
!strcmp("duration", atts[4]));
const size_t nProfileMappings = sizeof(sCamcorderQualityNameMap)/
sizeof(sCamcorderQualityNameMap[0]);
const int quality = findTagForName(sCamcorderQualityNameMap, nProfileMappings, atts[1]);
CHECK(quality != -1);
const size_t nFormatMappings = sizeof(sFileFormatMap)/sizeof(sFileFormatMap[0]);
const int fileFormat = findTagForName(sFileFormatMap, nFormatMappings, atts[3]);
CHECK(fileFormat != -1);
MediaProfiles::CamcorderProfile *profile = new MediaProfiles::CamcorderProfile;
profile->mCameraId = cameraId;
if (!isCameraIdFound(cameraId, cameraIds)) {
cameraIds.add(cameraId);
}
profile->mFileFormat = static_cast<output_format>(fileFormat);
profile->mQuality = static_cast<camcorder_quality>(quality);
profile->mDuration = atoi(atts[5]);
return profile;
}
MediaProfiles::ImageEncodingQualityLevels*
MediaProfiles::findImageEncodingQualityLevels(int cameraId) const
{
int n = mImageEncodingQualityLevels.size();
for (int i = 0; i < n; i++) {
ImageEncodingQualityLevels *levels = mImageEncodingQualityLevels[i];
if (levels->mCameraId == cameraId) {
return levels;
}
}
return NULL;
}
void MediaProfiles::addImageEncodingQualityLevel(int cameraId, const char** atts)
{
CHECK(!strcmp("quality", atts[0]));
int quality = atoi(atts[1]);
ALOGV("%s: cameraId=%d, quality=%d", __func__, cameraId, quality);
ImageEncodingQualityLevels *levels = findImageEncodingQualityLevels(cameraId);
if (levels == NULL) {
levels = new ImageEncodingQualityLevels();
levels->mCameraId = cameraId;
mImageEncodingQualityLevels.add(levels);
}
levels->mLevels.add(quality);
}
/*static*/ int
MediaProfiles::getCameraId(const char** atts)
{
if (!atts[0]) return 0; // default cameraId = 0
CHECK(!strcmp("cameraId", atts[0]));
return atoi(atts[1]);
}
void MediaProfiles::addStartTimeOffset(int cameraId, const char** atts)
{
int offsetTimeMs = 1000;
if (atts[2]) {
CHECK(!strcmp("startOffsetMs", atts[2]));
offsetTimeMs = atoi(atts[3]);
}
ALOGV("%s: cameraId=%d, offset=%d ms", __func__, cameraId, offsetTimeMs);
mStartTimeOffsets.replaceValueFor(cameraId, offsetTimeMs);
}
/*static*/ void
MediaProfiles::startElementHandler(void *userData, const char *name, const char **atts)
{
MediaProfiles *profiles = (MediaProfiles *) userData;
if (strcmp("Video", name) == 0) {
createVideoCodec(atts, profiles);
} else if (strcmp("Audio", name) == 0) {
createAudioCodec(atts, profiles);
} else if (strcmp("VideoEncoderCap", name) == 0 &&
strcmp("true", atts[3]) == 0) {
profiles->mVideoEncoders.add(createVideoEncoderCap(atts));
} else if (strcmp("AudioEncoderCap", name) == 0 &&
strcmp("true", atts[3]) == 0) {
profiles->mAudioEncoders.add(createAudioEncoderCap(atts));
} else if (strcmp("VideoDecoderCap", name) == 0 &&
strcmp("true", atts[3]) == 0) {
profiles->mVideoDecoders.add(createVideoDecoderCap(atts));
} else if (strcmp("AudioDecoderCap", name) == 0 &&
strcmp("true", atts[3]) == 0) {
profiles->mAudioDecoders.add(createAudioDecoderCap(atts));
} else if (strcmp("EncoderOutputFileFormat", name) == 0) {
profiles->mEncoderOutputFileFormats.add(createEncoderOutputFileFormat(atts));
} else if (strcmp("CamcorderProfiles", name) == 0) {
profiles->mCurrentCameraId = getCameraId(atts);
profiles->addStartTimeOffset(profiles->mCurrentCameraId, atts);
} else if (strcmp("EncoderProfile", name) == 0) {
profiles->mCamcorderProfiles.add(
createCamcorderProfile(profiles->mCurrentCameraId, atts, profiles->mCameraIds));
} else if (strcmp("ImageEncoding", name) == 0) {
profiles->addImageEncodingQualityLevel(profiles->mCurrentCameraId, atts);
}
}
static bool isCamcorderProfile(camcorder_quality quality) {
return quality >= CAMCORDER_QUALITY_LIST_START &&
quality <= CAMCORDER_QUALITY_LIST_END;
}
static bool isTimelapseProfile(camcorder_quality quality) {
return quality >= CAMCORDER_QUALITY_TIME_LAPSE_LIST_START &&
quality <= CAMCORDER_QUALITY_TIME_LAPSE_LIST_END;
}
static bool isHighSpeedProfile(camcorder_quality quality) {
return quality >= CAMCORDER_QUALITY_HIGH_SPEED_LIST_START &&
quality <= CAMCORDER_QUALITY_HIGH_SPEED_LIST_END;
}
void MediaProfiles::initRequiredProfileRefs(const Vector<int>& cameraIds) {
ALOGV("Number of camera ids: %zu", cameraIds.size());
CHECK(cameraIds.size() > 0);
mRequiredProfileRefs = new RequiredProfiles[cameraIds.size()];
for (size_t i = 0, n = cameraIds.size(); i < n; ++i) {
mRequiredProfileRefs[i].mCameraId = cameraIds[i];
for (size_t j = 0; j < kNumRequiredProfiles; ++j) {
mRequiredProfileRefs[i].mRefs[j].mHasRefProfile = false;
mRequiredProfileRefs[i].mRefs[j].mRefProfileIndex = -1;
if ((j & 1) == 0) { // low resolution
mRequiredProfileRefs[i].mRefs[j].mResolutionProduct = 0x7FFFFFFF;
} else { // high resolution
mRequiredProfileRefs[i].mRefs[j].mResolutionProduct = 0;
}
}
}
}
int MediaProfiles::getRequiredProfileRefIndex(int cameraId) {
for (size_t i = 0, n = mCameraIds.size(); i < n; ++i) {
if (mCameraIds[i] == cameraId) {
return i;
}
}
return -1;
}
void MediaProfiles::checkAndAddRequiredProfilesIfNecessary() {
if (sIsInitialized) {
return;
}
initRequiredProfileRefs(mCameraIds);
for (size_t i = 0, n = mCamcorderProfiles.size(); i < n; ++i) {
int product = mCamcorderProfiles[i]->mVideoCodec->mFrameWidth *
mCamcorderProfiles[i]->mVideoCodec->mFrameHeight;
camcorder_quality quality = mCamcorderProfiles[i]->mQuality;
int cameraId = mCamcorderProfiles[i]->mCameraId;
int index = -1;
int refIndex = getRequiredProfileRefIndex(cameraId);
CHECK(refIndex != -1);
RequiredProfileRefInfo *info;
camcorder_quality refQuality;
// Check high and low from either camcorder profile, timelapse profile
// or high speed profile, but not all of them. Default, check camcorder profile
size_t j = 0;
size_t o = 2;
if (isTimelapseProfile(quality)) {
// Check timelapse profile instead.
j = 2;
o = kNumRequiredProfiles;
} else if (isHighSpeedProfile(quality)) {
// Skip the check for high speed profile.
continue;
} else {
// Must be camcorder profile.
CHECK(isCamcorderProfile(quality));
}
for (; j < o; ++j) {
info = &(mRequiredProfileRefs[refIndex].mRefs[j]);
if ((j % 2 == 0 && product > info->mResolutionProduct) || // low
(j % 2 != 0 && product < info->mResolutionProduct)) { // high
continue;
}
switch (j) {
case 0:
refQuality = CAMCORDER_QUALITY_LOW;
break;
case 1:
refQuality = CAMCORDER_QUALITY_HIGH;
break;
case 2:
refQuality = CAMCORDER_QUALITY_TIME_LAPSE_LOW;
break;
case 3:
refQuality = CAMCORDER_QUALITY_TIME_LAPSE_HIGH;
break;
default:
CHECK(!"Should never reach here");
}
if (!info->mHasRefProfile) {
index = getCamcorderProfileIndex(cameraId, refQuality);
}
if (index == -1) {
// New high or low quality profile is found.
// Update its reference.
info->mHasRefProfile = true;
info->mRefProfileIndex = i;
info->mResolutionProduct = product;
}
}
}
for (size_t cameraId = 0; cameraId < mCameraIds.size(); ++cameraId) {
for (size_t j = 0; j < kNumRequiredProfiles; ++j) {
int refIndex = getRequiredProfileRefIndex(cameraId);
CHECK(refIndex != -1);
RequiredProfileRefInfo *info =
&mRequiredProfileRefs[refIndex].mRefs[j];
if (info->mHasRefProfile) {
CamcorderProfile *profile =
new CamcorderProfile(
*mCamcorderProfiles[info->mRefProfileIndex]);
// Overwrite the quality
switch (j % kNumRequiredProfiles) {
case 0:
profile->mQuality = CAMCORDER_QUALITY_LOW;
break;
case 1:
profile->mQuality = CAMCORDER_QUALITY_HIGH;
break;
case 2:
profile->mQuality = CAMCORDER_QUALITY_TIME_LAPSE_LOW;
break;
case 3:
profile->mQuality = CAMCORDER_QUALITY_TIME_LAPSE_HIGH;
break;
default:
CHECK(!"Should never come here");
}
int index = getCamcorderProfileIndex(cameraId, profile->mQuality);
if (index != -1) {
ALOGV("Profile quality %d for camera %zu already exists",
profile->mQuality, cameraId);
CHECK(index == refIndex);
continue;
}
// Insert the new profile
ALOGV("Add a profile: quality %d=>%d for camera %zu",
mCamcorderProfiles[info->mRefProfileIndex]->mQuality,
profile->mQuality, cameraId);
mCamcorderProfiles.add(profile);
}
}
}
}
/*static*/ MediaProfiles*
MediaProfiles::getInstance()
{
ALOGV("getInstance");
Mutex::Autolock lock(sLock);
if (!sIsInitialized) {
char value[PROPERTY_VALUE_MAX];
if (property_get("media.settings.xml", value, NULL) <= 0) {
const char *defaultXmlFile = "/etc/media_profiles.xml";
FILE *fp = fopen(defaultXmlFile, "r");
if (fp == NULL) {
ALOGW("could not find media config xml file");
sInstance = createDefaultInstance();
} else {
fclose(fp); // close the file first.
sInstance = createInstanceFromXmlFile(defaultXmlFile);
}
} else {
sInstance = createInstanceFromXmlFile(value);
}
CHECK(sInstance != NULL);
sInstance->checkAndAddRequiredProfilesIfNecessary();
sIsInitialized = true;
}
return sInstance;
}
/*static*/ MediaProfiles::VideoEncoderCap*
MediaProfiles::createDefaultH263VideoEncoderCap()
{
return new MediaProfiles::VideoEncoderCap(
VIDEO_ENCODER_H263, 192000, 420000, 176, 352, 144, 288, 1, 20);
}
/*static*/ MediaProfiles::VideoEncoderCap*
MediaProfiles::createDefaultM4vVideoEncoderCap()
{
return new MediaProfiles::VideoEncoderCap(
VIDEO_ENCODER_MPEG_4_SP, 192000, 420000, 176, 352, 144, 288, 1, 20);
}
/*static*/ void
MediaProfiles::createDefaultVideoEncoders(MediaProfiles *profiles)
{
profiles->mVideoEncoders.add(createDefaultH263VideoEncoderCap());
profiles->mVideoEncoders.add(createDefaultM4vVideoEncoderCap());
}
/*static*/ MediaProfiles::CamcorderProfile*
MediaProfiles::createDefaultCamcorderTimeLapseQcifProfile(camcorder_quality quality)
{
MediaProfiles::VideoCodec *videoCodec =
new MediaProfiles::VideoCodec(VIDEO_ENCODER_H263, 1000000, 176, 144, 20);
AudioCodec *audioCodec = new AudioCodec(AUDIO_ENCODER_AMR_NB, 12200, 8000, 1);
CamcorderProfile *profile = new MediaProfiles::CamcorderProfile;
profile->mCameraId = 0;
profile->mFileFormat = OUTPUT_FORMAT_THREE_GPP;
profile->mQuality = quality;
profile->mDuration = 60;
profile->mVideoCodec = videoCodec;
profile->mAudioCodec = audioCodec;
return profile;
}
/*static*/ MediaProfiles::CamcorderProfile*
MediaProfiles::createDefaultCamcorderTimeLapse480pProfile(camcorder_quality quality)
{
MediaProfiles::VideoCodec *videoCodec =
new MediaProfiles::VideoCodec(VIDEO_ENCODER_H263, 20000000, 720, 480, 20);
AudioCodec *audioCodec = new AudioCodec(AUDIO_ENCODER_AMR_NB, 12200, 8000, 1);
CamcorderProfile *profile = new MediaProfiles::CamcorderProfile;
profile->mCameraId = 0;
profile->mFileFormat = OUTPUT_FORMAT_THREE_GPP;
profile->mQuality = quality;
profile->mDuration = 60;
profile->mVideoCodec = videoCodec;
profile->mAudioCodec = audioCodec;
return profile;
}
/*static*/ void
MediaProfiles::createDefaultCamcorderTimeLapseLowProfiles(
MediaProfiles::CamcorderProfile **lowTimeLapseProfile,
MediaProfiles::CamcorderProfile **lowSpecificTimeLapseProfile) {
*lowTimeLapseProfile = createDefaultCamcorderTimeLapseQcifProfile(
CAMCORDER_QUALITY_TIME_LAPSE_LOW);
*lowSpecificTimeLapseProfile = createDefaultCamcorderTimeLapseQcifProfile(
CAMCORDER_QUALITY_TIME_LAPSE_QCIF);
}
/*static*/ void
MediaProfiles::createDefaultCamcorderTimeLapseHighProfiles(
MediaProfiles::CamcorderProfile **highTimeLapseProfile,
MediaProfiles::CamcorderProfile **highSpecificTimeLapseProfile) {
*highTimeLapseProfile = createDefaultCamcorderTimeLapse480pProfile(
CAMCORDER_QUALITY_TIME_LAPSE_HIGH);
*highSpecificTimeLapseProfile = createDefaultCamcorderTimeLapse480pProfile(
CAMCORDER_QUALITY_TIME_LAPSE_480P);
}
/*static*/ MediaProfiles::CamcorderProfile*
MediaProfiles::createDefaultCamcorderQcifProfile(camcorder_quality quality)
{
MediaProfiles::VideoCodec *videoCodec =
new MediaProfiles::VideoCodec(VIDEO_ENCODER_H263, 192000, 176, 144, 20);
MediaProfiles::AudioCodec *audioCodec =
new MediaProfiles::AudioCodec(AUDIO_ENCODER_AMR_NB, 12200, 8000, 1);
MediaProfiles::CamcorderProfile *profile = new MediaProfiles::CamcorderProfile;
profile->mCameraId = 0;
profile->mFileFormat = OUTPUT_FORMAT_THREE_GPP;
profile->mQuality = quality;
profile->mDuration = 30;
profile->mVideoCodec = videoCodec;
profile->mAudioCodec = audioCodec;
return profile;
}
/*static*/ MediaProfiles::CamcorderProfile*
MediaProfiles::createDefaultCamcorderCifProfile(camcorder_quality quality)
{
MediaProfiles::VideoCodec *videoCodec =
new MediaProfiles::VideoCodec(VIDEO_ENCODER_H263, 360000, 352, 288, 20);
AudioCodec *audioCodec = new AudioCodec(AUDIO_ENCODER_AMR_NB, 12200, 8000, 1);
CamcorderProfile *profile = new MediaProfiles::CamcorderProfile;
profile->mCameraId = 0;
profile->mFileFormat = OUTPUT_FORMAT_THREE_GPP;
profile->mQuality = quality;
profile->mDuration = 60;
profile->mVideoCodec = videoCodec;
profile->mAudioCodec = audioCodec;
return profile;
}
/*static*/ void
MediaProfiles::createDefaultCamcorderLowProfiles(
MediaProfiles::CamcorderProfile **lowProfile,
MediaProfiles::CamcorderProfile **lowSpecificProfile) {
*lowProfile = createDefaultCamcorderQcifProfile(CAMCORDER_QUALITY_LOW);
*lowSpecificProfile = createDefaultCamcorderQcifProfile(CAMCORDER_QUALITY_QCIF);
}
/*static*/ void
MediaProfiles::createDefaultCamcorderHighProfiles(
MediaProfiles::CamcorderProfile **highProfile,
MediaProfiles::CamcorderProfile **highSpecificProfile) {
*highProfile = createDefaultCamcorderCifProfile(CAMCORDER_QUALITY_HIGH);
*highSpecificProfile = createDefaultCamcorderCifProfile(CAMCORDER_QUALITY_CIF);
}
/*static*/ void
MediaProfiles::createDefaultCamcorderProfiles(MediaProfiles *profiles)
{
// low camcorder profiles.
MediaProfiles::CamcorderProfile *lowProfile, *lowSpecificProfile;
createDefaultCamcorderLowProfiles(&lowProfile, &lowSpecificProfile);
profiles->mCamcorderProfiles.add(lowProfile);
profiles->mCamcorderProfiles.add(lowSpecificProfile);
// high camcorder profiles.
MediaProfiles::CamcorderProfile* highProfile, *highSpecificProfile;
createDefaultCamcorderHighProfiles(&highProfile, &highSpecificProfile);
profiles->mCamcorderProfiles.add(highProfile);
profiles->mCamcorderProfiles.add(highSpecificProfile);
// low camcorder time lapse profiles.
MediaProfiles::CamcorderProfile *lowTimeLapseProfile, *lowSpecificTimeLapseProfile;
createDefaultCamcorderTimeLapseLowProfiles(&lowTimeLapseProfile, &lowSpecificTimeLapseProfile);
profiles->mCamcorderProfiles.add(lowTimeLapseProfile);
profiles->mCamcorderProfiles.add(lowSpecificTimeLapseProfile);
// high camcorder time lapse profiles.
MediaProfiles::CamcorderProfile *highTimeLapseProfile, *highSpecificTimeLapseProfile;
createDefaultCamcorderTimeLapseHighProfiles(&highTimeLapseProfile,
&highSpecificTimeLapseProfile);
profiles->mCamcorderProfiles.add(highTimeLapseProfile);
profiles->mCamcorderProfiles.add(highSpecificTimeLapseProfile);
// For emulator and other legacy devices which does not have a
// media_profiles.xml file, We assume that the default camera id
// is 0 and that is the only camera available.
profiles->mCameraIds.push(0);
}
/*static*/ void
MediaProfiles::createDefaultAudioEncoders(MediaProfiles *profiles)
{
profiles->mAudioEncoders.add(createDefaultAmrNBEncoderCap());
}
/*static*/ void
MediaProfiles::createDefaultVideoDecoders(MediaProfiles *profiles)
{
MediaProfiles::VideoDecoderCap *cap =
new MediaProfiles::VideoDecoderCap(VIDEO_DECODER_WMV);
profiles->mVideoDecoders.add(cap);
}
/*static*/ void
MediaProfiles::createDefaultAudioDecoders(MediaProfiles *profiles)
{
MediaProfiles::AudioDecoderCap *cap =
new MediaProfiles::AudioDecoderCap(AUDIO_DECODER_WMA);
profiles->mAudioDecoders.add(cap);
}
/*static*/ void
MediaProfiles::createDefaultEncoderOutputFileFormats(MediaProfiles *profiles)
{
profiles->mEncoderOutputFileFormats.add(OUTPUT_FORMAT_THREE_GPP);
profiles->mEncoderOutputFileFormats.add(OUTPUT_FORMAT_MPEG_4);
}
/*static*/ MediaProfiles::AudioEncoderCap*
MediaProfiles::createDefaultAmrNBEncoderCap()
{
return new MediaProfiles::AudioEncoderCap(
AUDIO_ENCODER_AMR_NB, 5525, 12200, 8000, 8000, 1, 1);
}
/*static*/ void
MediaProfiles::createDefaultImageEncodingQualityLevels(MediaProfiles *profiles)
{
ImageEncodingQualityLevels *levels = new ImageEncodingQualityLevels();
levels->mCameraId = 0;
levels->mLevels.add(70);
levels->mLevels.add(80);
levels->mLevels.add(90);
profiles->mImageEncodingQualityLevels.add(levels);
}
/*static*/ MediaProfiles*
MediaProfiles::createDefaultInstance()
{
MediaProfiles *profiles = new MediaProfiles;
createDefaultCamcorderProfiles(profiles);
createDefaultVideoEncoders(profiles);
createDefaultAudioEncoders(profiles);
createDefaultVideoDecoders(profiles);
createDefaultAudioDecoders(profiles);
createDefaultEncoderOutputFileFormats(profiles);
createDefaultImageEncodingQualityLevels(profiles);
return profiles;
}
/*static*/ MediaProfiles*
MediaProfiles::createInstanceFromXmlFile(const char *xml)
{
FILE *fp = NULL;
CHECK((fp = fopen(xml, "r")));
XML_Parser parser = ::XML_ParserCreate(NULL);
CHECK(parser != NULL);
MediaProfiles *profiles = new MediaProfiles();
::XML_SetUserData(parser, profiles);
::XML_SetElementHandler(parser, startElementHandler, NULL);
/*
FIXME:
expat is not compiled with -DXML_DTD. We don't have DTD parsing support.
if (!::XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS)) {
ALOGE("failed to enable DTD support in the xml file");
return UNKNOWN_ERROR;
}
*/
const int BUFF_SIZE = 512;
for (;;) {
void *buff = ::XML_GetBuffer(parser, BUFF_SIZE);
if (buff == NULL) {
ALOGE("failed to in call to XML_GetBuffer()");
delete profiles;
profiles = NULL;
goto exit;
}
int bytes_read = ::fread(buff, 1, BUFF_SIZE, fp);
if (bytes_read < 0) {
ALOGE("failed in call to read");
delete profiles;
profiles = NULL;
goto exit;
}
CHECK(::XML_ParseBuffer(parser, bytes_read, bytes_read == 0));
if (bytes_read == 0) break; // done parsing the xml file
}
exit:
::XML_ParserFree(parser);
::fclose(fp);
return profiles;
}
Vector<output_format> MediaProfiles::getOutputFileFormats() const
{
return mEncoderOutputFileFormats; // copy out
}
Vector<video_encoder> MediaProfiles::getVideoEncoders() const
{
Vector<video_encoder> encoders;
for (size_t i = 0; i < mVideoEncoders.size(); ++i) {
encoders.add(mVideoEncoders[i]->mCodec);
}
return encoders; // copy out
}
int MediaProfiles::getVideoEncoderParamByName(const char *name, video_encoder codec) const
{
ALOGV("getVideoEncoderParamByName: %s for codec %d", name, codec);
int index = -1;
for (size_t i = 0, n = mVideoEncoders.size(); i < n; ++i) {
if (mVideoEncoders[i]->mCodec == codec) {
index = i;
break;
}
}
if (index == -1) {
ALOGE("The given video encoder %d is not found", codec);
return -1;
}
if (!strcmp("enc.vid.width.min", name)) return mVideoEncoders[index]->mMinFrameWidth;
if (!strcmp("enc.vid.width.max", name)) return mVideoEncoders[index]->mMaxFrameWidth;
if (!strcmp("enc.vid.height.min", name)) return mVideoEncoders[index]->mMinFrameHeight;
if (!strcmp("enc.vid.height.max", name)) return mVideoEncoders[index]->mMaxFrameHeight;
if (!strcmp("enc.vid.bps.min", name)) return mVideoEncoders[index]->mMinBitRate;
if (!strcmp("enc.vid.bps.max", name)) return mVideoEncoders[index]->mMaxBitRate;
if (!strcmp("enc.vid.fps.min", name)) return mVideoEncoders[index]->mMinFrameRate;
if (!strcmp("enc.vid.fps.max", name)) return mVideoEncoders[index]->mMaxFrameRate;
ALOGE("The given video encoder param name %s is not found", name);
return -1;
}
Vector<audio_encoder> MediaProfiles::getAudioEncoders() const
{
Vector<audio_encoder> encoders;
for (size_t i = 0; i < mAudioEncoders.size(); ++i) {
encoders.add(mAudioEncoders[i]->mCodec);
}
return encoders; // copy out
}
int MediaProfiles::getAudioEncoderParamByName(const char *name, audio_encoder codec) const
{
ALOGV("getAudioEncoderParamByName: %s for codec %d", name, codec);
int index = -1;
for (size_t i = 0, n = mAudioEncoders.size(); i < n; ++i) {
if (mAudioEncoders[i]->mCodec == codec) {
index = i;
break;
}
}
if (index == -1) {
ALOGE("The given audio encoder %d is not found", codec);
return -1;
}
if (!strcmp("enc.aud.ch.min", name)) return mAudioEncoders[index]->mMinChannels;
if (!strcmp("enc.aud.ch.max", name)) return mAudioEncoders[index]->mMaxChannels;
if (!strcmp("enc.aud.bps.min", name)) return mAudioEncoders[index]->mMinBitRate;
if (!strcmp("enc.aud.bps.max", name)) return mAudioEncoders[index]->mMaxBitRate;
if (!strcmp("enc.aud.hz.min", name)) return mAudioEncoders[index]->mMinSampleRate;
if (!strcmp("enc.aud.hz.max", name)) return mAudioEncoders[index]->mMaxSampleRate;
ALOGE("The given audio encoder param name %s is not found", name);
return -1;
}
Vector<video_decoder> MediaProfiles::getVideoDecoders() const
{
Vector<video_decoder> decoders;
for (size_t i = 0; i < mVideoDecoders.size(); ++i) {
decoders.add(mVideoDecoders[i]->mCodec);
}
return decoders; // copy out
}
Vector<audio_decoder> MediaProfiles::getAudioDecoders() const
{
Vector<audio_decoder> decoders;
for (size_t i = 0; i < mAudioDecoders.size(); ++i) {
decoders.add(mAudioDecoders[i]->mCodec);
}
return decoders; // copy out
}
int MediaProfiles::getCamcorderProfileIndex(int cameraId, camcorder_quality quality) const
{
int index = -1;
for (size_t i = 0, n = mCamcorderProfiles.size(); i < n; ++i) {
if (mCamcorderProfiles[i]->mCameraId == cameraId &&
mCamcorderProfiles[i]->mQuality == quality) {
index = i;
break;
}
}
return index;
}
int MediaProfiles::getCamcorderProfileParamByName(const char *name,
int cameraId,
camcorder_quality quality) const
{
ALOGV("getCamcorderProfileParamByName: %s for camera %d, quality %d",
name, cameraId, quality);
int index = getCamcorderProfileIndex(cameraId, quality);
if (index == -1) {
ALOGE("The given camcorder profile camera %d quality %d is not found",
cameraId, quality);
return -1;
}
if (!strcmp("duration", name)) return mCamcorderProfiles[index]->mDuration;
if (!strcmp("file.format", name)) return mCamcorderProfiles[index]->mFileFormat;
if (!strcmp("vid.codec", name)) return mCamcorderProfiles[index]->mVideoCodec->mCodec;
if (!strcmp("vid.width", name)) return mCamcorderProfiles[index]->mVideoCodec->mFrameWidth;
if (!strcmp("vid.height", name)) return mCamcorderProfiles[index]->mVideoCodec->mFrameHeight;
if (!strcmp("vid.bps", name)) return mCamcorderProfiles[index]->mVideoCodec->mBitRate;
if (!strcmp("vid.fps", name)) return mCamcorderProfiles[index]->mVideoCodec->mFrameRate;
if (!strcmp("aud.codec", name)) return mCamcorderProfiles[index]->mAudioCodec->mCodec;
if (!strcmp("aud.bps", name)) return mCamcorderProfiles[index]->mAudioCodec->mBitRate;
if (!strcmp("aud.ch", name)) return mCamcorderProfiles[index]->mAudioCodec->mChannels;
if (!strcmp("aud.hz", name)) return mCamcorderProfiles[index]->mAudioCodec->mSampleRate;
ALOGE("The given camcorder profile param id %d name %s is not found", cameraId, name);
return -1;
}
bool MediaProfiles::hasCamcorderProfile(int cameraId, camcorder_quality quality) const
{
return (getCamcorderProfileIndex(cameraId, quality) != -1);
}
Vector<int> MediaProfiles::getImageEncodingQualityLevels(int cameraId) const
{
Vector<int> result;
ImageEncodingQualityLevels *levels = findImageEncodingQualityLevels(cameraId);
if (levels != NULL) {
result = levels->mLevels; // copy out
}
return result;
}
int MediaProfiles::getStartTimeOffsetMs(int cameraId) const {
int offsetTimeMs = -1;
ssize_t index = mStartTimeOffsets.indexOfKey(cameraId);
if (index >= 0) {
offsetTimeMs = mStartTimeOffsets.valueFor(cameraId);
}
ALOGV("offsetTime=%d ms and cameraId=%d", offsetTimeMs, cameraId);
return offsetTimeMs;
}
MediaProfiles::~MediaProfiles()
{
CHECK("destructor should never be called" == 0);
#if 0
for (size_t i = 0; i < mAudioEncoders.size(); ++i) {
delete mAudioEncoders[i];
}
mAudioEncoders.clear();
for (size_t i = 0; i < mVideoEncoders.size(); ++i) {
delete mVideoEncoders[i];
}
mVideoEncoders.clear();
for (size_t i = 0; i < mVideoDecoders.size(); ++i) {
delete mVideoDecoders[i];
}
mVideoDecoders.clear();
for (size_t i = 0; i < mAudioDecoders.size(); ++i) {
delete mAudioDecoders[i];
}
mAudioDecoders.clear();
for (size_t i = 0; i < mCamcorderProfiles.size(); ++i) {
delete mCamcorderProfiles[i];
}
mCamcorderProfiles.clear();
#endif
}
} // namespace android