MediaProfiles.cpp revision e07909715b44cc56df723750af93f0608210f94d
1/* 2** 3** Copyright 2010, The Android Open Source Project 4** 5** Licensed under the Apache License, Version 2.0 (the "License"); 6** you may not use this file except in compliance with the License. 7** You may obtain a copy of the License at 8** 9** http://www.apache.org/licenses/LICENSE-2.0 10** 11** Unless required by applicable law or agreed to in writing, software 12** distributed under the License is distributed on an "AS IS" BASIS, 13** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14** See the License for the specific language governing permissions and 15** limitations under the License. 16*/ 17 18 19//#define LOG_NDEBUG 0 20#define LOG_TAG "MediaProfiles" 21 22#include <stdlib.h> 23#include <utils/Log.h> 24#include <utils/Vector.h> 25#include <cutils/properties.h> 26#include <libexpat/expat.h> 27#include <media/MediaProfiles.h> 28#include <media/stagefright/foundation/ADebug.h> 29#include <OMX_Video.h> 30 31namespace android { 32 33Mutex MediaProfiles::sLock; 34bool MediaProfiles::sIsInitialized = false; 35MediaProfiles *MediaProfiles::sInstance = NULL; 36 37const MediaProfiles::NameToTagMap MediaProfiles::sVideoEncoderNameMap[] = { 38 {"h263", VIDEO_ENCODER_H263}, 39 {"h264", VIDEO_ENCODER_H264}, 40 {"m4v", VIDEO_ENCODER_MPEG_4_SP} 41}; 42 43const MediaProfiles::NameToTagMap MediaProfiles::sAudioEncoderNameMap[] = { 44 {"amrnb", AUDIO_ENCODER_AMR_NB}, 45 {"amrwb", AUDIO_ENCODER_AMR_WB}, 46 {"aac", AUDIO_ENCODER_AAC}, 47 {"heaac", AUDIO_ENCODER_HE_AAC}, 48 {"aaceld", AUDIO_ENCODER_AAC_ELD} 49}; 50 51const MediaProfiles::NameToTagMap MediaProfiles::sFileFormatMap[] = { 52 {"3gp", OUTPUT_FORMAT_THREE_GPP}, 53 {"mp4", OUTPUT_FORMAT_MPEG_4} 54}; 55 56const MediaProfiles::NameToTagMap MediaProfiles::sVideoDecoderNameMap[] = { 57 {"wmv", VIDEO_DECODER_WMV} 58}; 59 60const MediaProfiles::NameToTagMap MediaProfiles::sAudioDecoderNameMap[] = { 61 {"wma", AUDIO_DECODER_WMA} 62}; 63 64const MediaProfiles::NameToTagMap MediaProfiles::sCamcorderQualityNameMap[] = { 65 {"low", CAMCORDER_QUALITY_LOW}, 66 {"high", CAMCORDER_QUALITY_HIGH}, 67 {"qcif", CAMCORDER_QUALITY_QCIF}, 68 {"cif", CAMCORDER_QUALITY_CIF}, 69 {"480p", CAMCORDER_QUALITY_480P}, 70 {"720p", CAMCORDER_QUALITY_720P}, 71 {"1080p", CAMCORDER_QUALITY_1080P}, 72 {"2160p", CAMCORDER_QUALITY_2160P}, 73 {"qvga", CAMCORDER_QUALITY_QVGA}, 74 75 {"timelapselow", CAMCORDER_QUALITY_TIME_LAPSE_LOW}, 76 {"timelapsehigh", CAMCORDER_QUALITY_TIME_LAPSE_HIGH}, 77 {"timelapseqcif", CAMCORDER_QUALITY_TIME_LAPSE_QCIF}, 78 {"timelapsecif", CAMCORDER_QUALITY_TIME_LAPSE_CIF}, 79 {"timelapse480p", CAMCORDER_QUALITY_TIME_LAPSE_480P}, 80 {"timelapse720p", CAMCORDER_QUALITY_TIME_LAPSE_720P}, 81 {"timelapse1080p", CAMCORDER_QUALITY_TIME_LAPSE_1080P}, 82 {"timelapse2160p", CAMCORDER_QUALITY_TIME_LAPSE_2160P}, 83 {"timelapseqvga", CAMCORDER_QUALITY_TIME_LAPSE_QVGA}, 84 85 {"highspeedlow", CAMCORDER_QUALITY_HIGH_SPEED_LOW}, 86 {"highspeedhigh", CAMCORDER_QUALITY_HIGH_SPEED_HIGH}, 87 {"highspeed480p", CAMCORDER_QUALITY_HIGH_SPEED_480P}, 88 {"highspeed720p", CAMCORDER_QUALITY_HIGH_SPEED_720P}, 89 {"highspeed1080p", CAMCORDER_QUALITY_HIGH_SPEED_1080P}, 90}; 91 92#if LOG_NDEBUG 93#define UNUSED __unused 94#else 95#define UNUSED 96#endif 97 98/*static*/ void 99MediaProfiles::logVideoCodec(const MediaProfiles::VideoCodec& codec UNUSED) 100{ 101 ALOGV("video codec:"); 102 ALOGV("codec = %d", codec.mCodec); 103 ALOGV("bit rate: %d", codec.mBitRate); 104 ALOGV("frame width: %d", codec.mFrameWidth); 105 ALOGV("frame height: %d", codec.mFrameHeight); 106 ALOGV("frame rate: %d", codec.mFrameRate); 107} 108 109/*static*/ void 110MediaProfiles::logAudioCodec(const MediaProfiles::AudioCodec& codec UNUSED) 111{ 112 ALOGV("audio codec:"); 113 ALOGV("codec = %d", codec.mCodec); 114 ALOGV("bit rate: %d", codec.mBitRate); 115 ALOGV("sample rate: %d", codec.mSampleRate); 116 ALOGV("number of channels: %d", codec.mChannels); 117} 118 119/*static*/ void 120MediaProfiles::logVideoEncoderCap(const MediaProfiles::VideoEncoderCap& cap UNUSED) 121{ 122 ALOGV("video encoder cap:"); 123 ALOGV("codec = %d", cap.mCodec); 124 ALOGV("bit rate: min = %d and max = %d", cap.mMinBitRate, cap.mMaxBitRate); 125 ALOGV("frame width: min = %d and max = %d", cap.mMinFrameWidth, cap.mMaxFrameWidth); 126 ALOGV("frame height: min = %d and max = %d", cap.mMinFrameHeight, cap.mMaxFrameHeight); 127 ALOGV("frame rate: min = %d and max = %d", cap.mMinFrameRate, cap.mMaxFrameRate); 128} 129 130/*static*/ void 131MediaProfiles::logAudioEncoderCap(const MediaProfiles::AudioEncoderCap& cap UNUSED) 132{ 133 ALOGV("audio encoder cap:"); 134 ALOGV("codec = %d", cap.mCodec); 135 ALOGV("bit rate: min = %d and max = %d", cap.mMinBitRate, cap.mMaxBitRate); 136 ALOGV("sample rate: min = %d and max = %d", cap.mMinSampleRate, cap.mMaxSampleRate); 137 ALOGV("number of channels: min = %d and max = %d", cap.mMinChannels, cap.mMaxChannels); 138} 139 140/*static*/ void 141MediaProfiles::logVideoDecoderCap(const MediaProfiles::VideoDecoderCap& cap UNUSED) 142{ 143 ALOGV("video decoder cap:"); 144 ALOGV("codec = %d", cap.mCodec); 145} 146 147/*static*/ void 148MediaProfiles::logAudioDecoderCap(const MediaProfiles::AudioDecoderCap& cap UNUSED) 149{ 150 ALOGV("audio codec cap:"); 151 ALOGV("codec = %d", cap.mCodec); 152} 153 154/*static*/ void 155MediaProfiles::logVideoEditorCap(const MediaProfiles::VideoEditorCap& cap UNUSED) 156{ 157 ALOGV("videoeditor cap:"); 158 ALOGV("mMaxInputFrameWidth = %d", cap.mMaxInputFrameWidth); 159 ALOGV("mMaxInputFrameHeight = %d", cap.mMaxInputFrameHeight); 160 ALOGV("mMaxOutputFrameWidth = %d", cap.mMaxOutputFrameWidth); 161 ALOGV("mMaxOutputFrameHeight = %d", cap.mMaxOutputFrameHeight); 162} 163 164/*static*/ int 165MediaProfiles::findTagForName(const MediaProfiles::NameToTagMap *map, size_t nMappings, const char *name) 166{ 167 int tag = -1; 168 for (size_t i = 0; i < nMappings; ++i) { 169 if (!strcmp(map[i].name, name)) { 170 tag = map[i].tag; 171 break; 172 } 173 } 174 return tag; 175} 176 177/*static*/ MediaProfiles::VideoCodec* 178MediaProfiles::createVideoCodec(const char **atts, MediaProfiles *profiles) 179{ 180 CHECK(!strcmp("codec", atts[0]) && 181 !strcmp("bitRate", atts[2]) && 182 !strcmp("width", atts[4]) && 183 !strcmp("height", atts[6]) && 184 !strcmp("frameRate", atts[8])); 185 186 const size_t nMappings = sizeof(sVideoEncoderNameMap)/sizeof(sVideoEncoderNameMap[0]); 187 const int codec = findTagForName(sVideoEncoderNameMap, nMappings, atts[1]); 188 CHECK(codec != -1); 189 190 MediaProfiles::VideoCodec *videoCodec = 191 new MediaProfiles::VideoCodec(static_cast<video_encoder>(codec), 192 atoi(atts[3]), atoi(atts[5]), atoi(atts[7]), atoi(atts[9])); 193 logVideoCodec(*videoCodec); 194 195 size_t nCamcorderProfiles; 196 CHECK((nCamcorderProfiles = profiles->mCamcorderProfiles.size()) >= 1); 197 profiles->mCamcorderProfiles[nCamcorderProfiles - 1]->mVideoCodec = videoCodec; 198 return videoCodec; 199} 200 201/*static*/ MediaProfiles::AudioCodec* 202MediaProfiles::createAudioCodec(const char **atts, MediaProfiles *profiles) 203{ 204 CHECK(!strcmp("codec", atts[0]) && 205 !strcmp("bitRate", atts[2]) && 206 !strcmp("sampleRate", atts[4]) && 207 !strcmp("channels", atts[6])); 208 const size_t nMappings = sizeof(sAudioEncoderNameMap)/sizeof(sAudioEncoderNameMap[0]); 209 const int codec = findTagForName(sAudioEncoderNameMap, nMappings, atts[1]); 210 CHECK(codec != -1); 211 212 MediaProfiles::AudioCodec *audioCodec = 213 new MediaProfiles::AudioCodec(static_cast<audio_encoder>(codec), 214 atoi(atts[3]), atoi(atts[5]), atoi(atts[7])); 215 logAudioCodec(*audioCodec); 216 217 size_t nCamcorderProfiles; 218 CHECK((nCamcorderProfiles = profiles->mCamcorderProfiles.size()) >= 1); 219 profiles->mCamcorderProfiles[nCamcorderProfiles - 1]->mAudioCodec = audioCodec; 220 return audioCodec; 221} 222/*static*/ MediaProfiles::AudioDecoderCap* 223MediaProfiles::createAudioDecoderCap(const char **atts) 224{ 225 CHECK(!strcmp("name", atts[0]) && 226 !strcmp("enabled", atts[2])); 227 228 const size_t nMappings = sizeof(sAudioDecoderNameMap)/sizeof(sAudioDecoderNameMap[0]); 229 const int codec = findTagForName(sAudioDecoderNameMap, nMappings, atts[1]); 230 CHECK(codec != -1); 231 232 MediaProfiles::AudioDecoderCap *cap = 233 new MediaProfiles::AudioDecoderCap(static_cast<audio_decoder>(codec)); 234 logAudioDecoderCap(*cap); 235 return cap; 236} 237 238/*static*/ MediaProfiles::VideoDecoderCap* 239MediaProfiles::createVideoDecoderCap(const char **atts) 240{ 241 CHECK(!strcmp("name", atts[0]) && 242 !strcmp("enabled", atts[2])); 243 244 const size_t nMappings = sizeof(sVideoDecoderNameMap)/sizeof(sVideoDecoderNameMap[0]); 245 const int codec = findTagForName(sVideoDecoderNameMap, nMappings, atts[1]); 246 CHECK(codec != -1); 247 248 MediaProfiles::VideoDecoderCap *cap = 249 new MediaProfiles::VideoDecoderCap(static_cast<video_decoder>(codec)); 250 logVideoDecoderCap(*cap); 251 return cap; 252} 253 254/*static*/ MediaProfiles::VideoEncoderCap* 255MediaProfiles::createVideoEncoderCap(const char **atts) 256{ 257 CHECK(!strcmp("name", atts[0]) && 258 !strcmp("enabled", atts[2]) && 259 !strcmp("minBitRate", atts[4]) && 260 !strcmp("maxBitRate", atts[6]) && 261 !strcmp("minFrameWidth", atts[8]) && 262 !strcmp("maxFrameWidth", atts[10]) && 263 !strcmp("minFrameHeight", atts[12]) && 264 !strcmp("maxFrameHeight", atts[14]) && 265 !strcmp("minFrameRate", atts[16]) && 266 !strcmp("maxFrameRate", atts[18])); 267 268 const size_t nMappings = sizeof(sVideoEncoderNameMap)/sizeof(sVideoEncoderNameMap[0]); 269 const int codec = findTagForName(sVideoEncoderNameMap, nMappings, atts[1]); 270 CHECK(codec != -1); 271 272 MediaProfiles::VideoEncoderCap *cap = 273 new MediaProfiles::VideoEncoderCap(static_cast<video_encoder>(codec), 274 atoi(atts[5]), atoi(atts[7]), atoi(atts[9]), atoi(atts[11]), atoi(atts[13]), 275 atoi(atts[15]), atoi(atts[17]), atoi(atts[19])); 276 logVideoEncoderCap(*cap); 277 return cap; 278} 279 280/*static*/ MediaProfiles::AudioEncoderCap* 281MediaProfiles::createAudioEncoderCap(const char **atts) 282{ 283 CHECK(!strcmp("name", atts[0]) && 284 !strcmp("enabled", atts[2]) && 285 !strcmp("minBitRate", atts[4]) && 286 !strcmp("maxBitRate", atts[6]) && 287 !strcmp("minSampleRate", atts[8]) && 288 !strcmp("maxSampleRate", atts[10]) && 289 !strcmp("minChannels", atts[12]) && 290 !strcmp("maxChannels", atts[14])); 291 292 const size_t nMappings = sizeof(sAudioEncoderNameMap)/sizeof(sAudioEncoderNameMap[0]); 293 const int codec = findTagForName(sAudioEncoderNameMap, nMappings, atts[1]); 294 CHECK(codec != -1); 295 296 MediaProfiles::AudioEncoderCap *cap = 297 new MediaProfiles::AudioEncoderCap(static_cast<audio_encoder>(codec), atoi(atts[5]), atoi(atts[7]), 298 atoi(atts[9]), atoi(atts[11]), atoi(atts[13]), 299 atoi(atts[15])); 300 logAudioEncoderCap(*cap); 301 return cap; 302} 303 304/*static*/ output_format 305MediaProfiles::createEncoderOutputFileFormat(const char **atts) 306{ 307 CHECK(!strcmp("name", atts[0])); 308 309 const size_t nMappings =sizeof(sFileFormatMap)/sizeof(sFileFormatMap[0]); 310 const int format = findTagForName(sFileFormatMap, nMappings, atts[1]); 311 CHECK(format != -1); 312 313 return static_cast<output_format>(format); 314} 315 316static bool isCameraIdFound(int cameraId, const Vector<int>& cameraIds) { 317 for (int i = 0, n = cameraIds.size(); i < n; ++i) { 318 if (cameraId == cameraIds[i]) { 319 return true; 320 } 321 } 322 return false; 323} 324 325/*static*/ MediaProfiles::CamcorderProfile* 326MediaProfiles::createCamcorderProfile(int cameraId, const char **atts, Vector<int>& cameraIds) 327{ 328 CHECK(!strcmp("quality", atts[0]) && 329 !strcmp("fileFormat", atts[2]) && 330 !strcmp("duration", atts[4])); 331 332 const size_t nProfileMappings = sizeof(sCamcorderQualityNameMap)/sizeof(sCamcorderQualityNameMap[0]); 333 const int quality = findTagForName(sCamcorderQualityNameMap, nProfileMappings, atts[1]); 334 CHECK(quality != -1); 335 336 const size_t nFormatMappings = sizeof(sFileFormatMap)/sizeof(sFileFormatMap[0]); 337 const int fileFormat = findTagForName(sFileFormatMap, nFormatMappings, atts[3]); 338 CHECK(fileFormat != -1); 339 340 MediaProfiles::CamcorderProfile *profile = new MediaProfiles::CamcorderProfile; 341 profile->mCameraId = cameraId; 342 if (!isCameraIdFound(cameraId, cameraIds)) { 343 cameraIds.add(cameraId); 344 } 345 profile->mFileFormat = static_cast<output_format>(fileFormat); 346 profile->mQuality = static_cast<camcorder_quality>(quality); 347 profile->mDuration = atoi(atts[5]); 348 return profile; 349} 350 351MediaProfiles::ImageEncodingQualityLevels* 352MediaProfiles::findImageEncodingQualityLevels(int cameraId) const 353{ 354 int n = mImageEncodingQualityLevels.size(); 355 for (int i = 0; i < n; i++) { 356 ImageEncodingQualityLevels *levels = mImageEncodingQualityLevels[i]; 357 if (levels->mCameraId == cameraId) { 358 return levels; 359 } 360 } 361 return NULL; 362} 363 364void MediaProfiles::addImageEncodingQualityLevel(int cameraId, const char** atts) 365{ 366 CHECK(!strcmp("quality", atts[0])); 367 int quality = atoi(atts[1]); 368 ALOGV("%s: cameraId=%d, quality=%d", __func__, cameraId, quality); 369 ImageEncodingQualityLevels *levels = findImageEncodingQualityLevels(cameraId); 370 371 if (levels == NULL) { 372 levels = new ImageEncodingQualityLevels(); 373 levels->mCameraId = cameraId; 374 mImageEncodingQualityLevels.add(levels); 375 } 376 377 levels->mLevels.add(quality); 378} 379 380/*static*/ int 381MediaProfiles::getCameraId(const char** atts) 382{ 383 if (!atts[0]) return 0; // default cameraId = 0 384 CHECK(!strcmp("cameraId", atts[0])); 385 return atoi(atts[1]); 386} 387 388void MediaProfiles::addStartTimeOffset(int cameraId, const char** atts) 389{ 390 int offsetTimeMs = 1000; 391 if (atts[2]) { 392 CHECK(!strcmp("startOffsetMs", atts[2])); 393 offsetTimeMs = atoi(atts[3]); 394 } 395 396 ALOGV("%s: cameraId=%d, offset=%d ms", __func__, cameraId, offsetTimeMs); 397 mStartTimeOffsets.replaceValueFor(cameraId, offsetTimeMs); 398} 399/*static*/ MediaProfiles::ExportVideoProfile* 400MediaProfiles::createExportVideoProfile(const char **atts) 401{ 402 CHECK(!strcmp("name", atts[0]) && 403 !strcmp("profile", atts[2]) && 404 !strcmp("level", atts[4])); 405 406 const size_t nMappings = 407 sizeof(sVideoEncoderNameMap)/sizeof(sVideoEncoderNameMap[0]); 408 const int codec = findTagForName(sVideoEncoderNameMap, nMappings, atts[1]); 409 CHECK(codec != -1); 410 411 MediaProfiles::ExportVideoProfile *profile = 412 new MediaProfiles::ExportVideoProfile( 413 codec, atoi(atts[3]), atoi(atts[5])); 414 415 return profile; 416} 417/*static*/ MediaProfiles::VideoEditorCap* 418MediaProfiles::createVideoEditorCap(const char **atts, MediaProfiles *profiles) 419{ 420 CHECK(!strcmp("maxInputFrameWidth", atts[0]) && 421 !strcmp("maxInputFrameHeight", atts[2]) && 422 !strcmp("maxOutputFrameWidth", atts[4]) && 423 !strcmp("maxOutputFrameHeight", atts[6]) && 424 !strcmp("maxPrefetchYUVFrames", atts[8])); 425 426 MediaProfiles::VideoEditorCap *pVideoEditorCap = 427 new MediaProfiles::VideoEditorCap(atoi(atts[1]), atoi(atts[3]), 428 atoi(atts[5]), atoi(atts[7]), atoi(atts[9])); 429 430 logVideoEditorCap(*pVideoEditorCap); 431 profiles->mVideoEditorCap = pVideoEditorCap; 432 433 return pVideoEditorCap; 434} 435 436/*static*/ void 437MediaProfiles::startElementHandler(void *userData, const char *name, const char **atts) 438{ 439 MediaProfiles *profiles = (MediaProfiles *) userData; 440 if (strcmp("Video", name) == 0) { 441 createVideoCodec(atts, profiles); 442 } else if (strcmp("Audio", name) == 0) { 443 createAudioCodec(atts, profiles); 444 } else if (strcmp("VideoEncoderCap", name) == 0 && 445 strcmp("true", atts[3]) == 0) { 446 profiles->mVideoEncoders.add(createVideoEncoderCap(atts)); 447 } else if (strcmp("AudioEncoderCap", name) == 0 && 448 strcmp("true", atts[3]) == 0) { 449 profiles->mAudioEncoders.add(createAudioEncoderCap(atts)); 450 } else if (strcmp("VideoDecoderCap", name) == 0 && 451 strcmp("true", atts[3]) == 0) { 452 profiles->mVideoDecoders.add(createVideoDecoderCap(atts)); 453 } else if (strcmp("AudioDecoderCap", name) == 0 && 454 strcmp("true", atts[3]) == 0) { 455 profiles->mAudioDecoders.add(createAudioDecoderCap(atts)); 456 } else if (strcmp("EncoderOutputFileFormat", name) == 0) { 457 profiles->mEncoderOutputFileFormats.add(createEncoderOutputFileFormat(atts)); 458 } else if (strcmp("CamcorderProfiles", name) == 0) { 459 profiles->mCurrentCameraId = getCameraId(atts); 460 profiles->addStartTimeOffset(profiles->mCurrentCameraId, atts); 461 } else if (strcmp("EncoderProfile", name) == 0) { 462 profiles->mCamcorderProfiles.add( 463 createCamcorderProfile(profiles->mCurrentCameraId, atts, profiles->mCameraIds)); 464 } else if (strcmp("ImageEncoding", name) == 0) { 465 profiles->addImageEncodingQualityLevel(profiles->mCurrentCameraId, atts); 466 } else if (strcmp("VideoEditorCap", name) == 0) { 467 createVideoEditorCap(atts, profiles); 468 } else if (strcmp("ExportVideoProfile", name) == 0) { 469 profiles->mVideoEditorExportProfiles.add(createExportVideoProfile(atts)); 470 } 471} 472 473static bool isCamcorderProfile(camcorder_quality quality) { 474 return quality >= CAMCORDER_QUALITY_LIST_START && 475 quality <= CAMCORDER_QUALITY_LIST_END; 476} 477 478static bool isTimelapseProfile(camcorder_quality quality) { 479 return quality >= CAMCORDER_QUALITY_TIME_LAPSE_LIST_START && 480 quality <= CAMCORDER_QUALITY_TIME_LAPSE_LIST_END; 481} 482 483static bool isHighSpeedProfile(camcorder_quality quality) { 484 return quality >= CAMCORDER_QUALITY_HIGH_SPEED_LIST_START && 485 quality <= CAMCORDER_QUALITY_HIGH_SPEED_LIST_END; 486} 487 488void MediaProfiles::initRequiredProfileRefs(const Vector<int>& cameraIds) { 489 ALOGV("Number of camera ids: %zu", cameraIds.size()); 490 CHECK(cameraIds.size() > 0); 491 mRequiredProfileRefs = new RequiredProfiles[cameraIds.size()]; 492 for (size_t i = 0, n = cameraIds.size(); i < n; ++i) { 493 mRequiredProfileRefs[i].mCameraId = cameraIds[i]; 494 for (size_t j = 0; j < kNumRequiredProfiles; ++j) { 495 mRequiredProfileRefs[i].mRefs[j].mHasRefProfile = false; 496 mRequiredProfileRefs[i].mRefs[j].mRefProfileIndex = -1; 497 if ((j & 1) == 0) { // low resolution 498 mRequiredProfileRefs[i].mRefs[j].mResolutionProduct = 0x7FFFFFFF; 499 } else { // high resolution 500 mRequiredProfileRefs[i].mRefs[j].mResolutionProduct = 0; 501 } 502 } 503 } 504} 505 506int MediaProfiles::getRequiredProfileRefIndex(int cameraId) { 507 for (size_t i = 0, n = mCameraIds.size(); i < n; ++i) { 508 if (mCameraIds[i] == cameraId) { 509 return i; 510 } 511 } 512 return -1; 513} 514 515void MediaProfiles::checkAndAddRequiredProfilesIfNecessary() { 516 if (sIsInitialized) { 517 return; 518 } 519 520 initRequiredProfileRefs(mCameraIds); 521 522 for (size_t i = 0, n = mCamcorderProfiles.size(); i < n; ++i) { 523 int product = mCamcorderProfiles[i]->mVideoCodec->mFrameWidth * 524 mCamcorderProfiles[i]->mVideoCodec->mFrameHeight; 525 526 camcorder_quality quality = mCamcorderProfiles[i]->mQuality; 527 int cameraId = mCamcorderProfiles[i]->mCameraId; 528 int index = -1; 529 int refIndex = getRequiredProfileRefIndex(cameraId); 530 CHECK(refIndex != -1); 531 RequiredProfileRefInfo *info; 532 camcorder_quality refQuality; 533 VideoCodec *codec = NULL; 534 535 // Check high and low from either camcorder profile, timelapse profile 536 // or high speed profile, but not all of them. Default, check camcorder profile 537 size_t j = 0; 538 size_t o = 2; 539 if (isTimelapseProfile(quality)) { 540 // Check timelapse profile instead. 541 j = 2; 542 o = kNumRequiredProfiles; 543 } else if (isHighSpeedProfile(quality)) { 544 // Skip the check for high speed profile. 545 continue; 546 } else { 547 // Must be camcorder profile. 548 CHECK(isCamcorderProfile(quality)); 549 } 550 for (; j < o; ++j) { 551 info = &(mRequiredProfileRefs[refIndex].mRefs[j]); 552 if ((j % 2 == 0 && product > info->mResolutionProduct) || // low 553 (j % 2 != 0 && product < info->mResolutionProduct)) { // high 554 continue; 555 } 556 switch (j) { 557 case 0: 558 refQuality = CAMCORDER_QUALITY_LOW; 559 break; 560 case 1: 561 refQuality = CAMCORDER_QUALITY_HIGH; 562 break; 563 case 2: 564 refQuality = CAMCORDER_QUALITY_TIME_LAPSE_LOW; 565 break; 566 case 3: 567 refQuality = CAMCORDER_QUALITY_TIME_LAPSE_HIGH; 568 break; 569 default: 570 CHECK(!"Should never reach here"); 571 } 572 573 if (!info->mHasRefProfile) { 574 index = getCamcorderProfileIndex(cameraId, refQuality); 575 } 576 if (index == -1) { 577 // New high or low quality profile is found. 578 // Update its reference. 579 info->mHasRefProfile = true; 580 info->mRefProfileIndex = i; 581 info->mResolutionProduct = product; 582 } 583 } 584 } 585 586 for (size_t cameraId = 0; cameraId < mCameraIds.size(); ++cameraId) { 587 for (size_t j = 0; j < kNumRequiredProfiles; ++j) { 588 int refIndex = getRequiredProfileRefIndex(cameraId); 589 CHECK(refIndex != -1); 590 RequiredProfileRefInfo *info = 591 &mRequiredProfileRefs[refIndex].mRefs[j]; 592 593 if (info->mHasRefProfile) { 594 595 CamcorderProfile *profile = 596 new CamcorderProfile( 597 *mCamcorderProfiles[info->mRefProfileIndex]); 598 599 // Overwrite the quality 600 switch (j % kNumRequiredProfiles) { 601 case 0: 602 profile->mQuality = CAMCORDER_QUALITY_LOW; 603 break; 604 case 1: 605 profile->mQuality = CAMCORDER_QUALITY_HIGH; 606 break; 607 case 2: 608 profile->mQuality = CAMCORDER_QUALITY_TIME_LAPSE_LOW; 609 break; 610 case 3: 611 profile->mQuality = CAMCORDER_QUALITY_TIME_LAPSE_HIGH; 612 break; 613 default: 614 CHECK(!"Should never come here"); 615 } 616 617 int index = getCamcorderProfileIndex(cameraId, profile->mQuality); 618 if (index != -1) { 619 ALOGV("Profile quality %d for camera %zu already exists", 620 profile->mQuality, cameraId); 621 CHECK(index == refIndex); 622 continue; 623 } 624 625 // Insert the new profile 626 ALOGV("Add a profile: quality %d=>%d for camera %zu", 627 mCamcorderProfiles[info->mRefProfileIndex]->mQuality, 628 profile->mQuality, cameraId); 629 630 mCamcorderProfiles.add(profile); 631 } 632 } 633 } 634} 635 636/*static*/ MediaProfiles* 637MediaProfiles::getInstance() 638{ 639 ALOGV("getInstance"); 640 Mutex::Autolock lock(sLock); 641 if (!sIsInitialized) { 642 char value[PROPERTY_VALUE_MAX]; 643 if (property_get("media.settings.xml", value, NULL) <= 0) { 644 const char *defaultXmlFile = "/etc/media_profiles.xml"; 645 FILE *fp = fopen(defaultXmlFile, "r"); 646 if (fp == NULL) { 647 ALOGW("could not find media config xml file"); 648 sInstance = createDefaultInstance(); 649 } else { 650 fclose(fp); // close the file first. 651 sInstance = createInstanceFromXmlFile(defaultXmlFile); 652 } 653 } else { 654 sInstance = createInstanceFromXmlFile(value); 655 } 656 CHECK(sInstance != NULL); 657 sInstance->checkAndAddRequiredProfilesIfNecessary(); 658 sIsInitialized = true; 659 } 660 661 return sInstance; 662} 663 664/*static*/ MediaProfiles::VideoEncoderCap* 665MediaProfiles::createDefaultH263VideoEncoderCap() 666{ 667 return new MediaProfiles::VideoEncoderCap( 668 VIDEO_ENCODER_H263, 192000, 420000, 176, 352, 144, 288, 1, 20); 669} 670 671/*static*/ MediaProfiles::VideoEncoderCap* 672MediaProfiles::createDefaultM4vVideoEncoderCap() 673{ 674 return new MediaProfiles::VideoEncoderCap( 675 VIDEO_ENCODER_MPEG_4_SP, 192000, 420000, 176, 352, 144, 288, 1, 20); 676} 677 678 679/*static*/ void 680MediaProfiles::createDefaultVideoEncoders(MediaProfiles *profiles) 681{ 682 profiles->mVideoEncoders.add(createDefaultH263VideoEncoderCap()); 683 profiles->mVideoEncoders.add(createDefaultM4vVideoEncoderCap()); 684} 685 686/*static*/ MediaProfiles::CamcorderProfile* 687MediaProfiles::createDefaultCamcorderTimeLapseQcifProfile(camcorder_quality quality) 688{ 689 MediaProfiles::VideoCodec *videoCodec = 690 new MediaProfiles::VideoCodec(VIDEO_ENCODER_H263, 1000000, 176, 144, 20); 691 692 AudioCodec *audioCodec = new AudioCodec(AUDIO_ENCODER_AMR_NB, 12200, 8000, 1); 693 CamcorderProfile *profile = new MediaProfiles::CamcorderProfile; 694 profile->mCameraId = 0; 695 profile->mFileFormat = OUTPUT_FORMAT_THREE_GPP; 696 profile->mQuality = quality; 697 profile->mDuration = 60; 698 profile->mVideoCodec = videoCodec; 699 profile->mAudioCodec = audioCodec; 700 return profile; 701} 702 703/*static*/ MediaProfiles::CamcorderProfile* 704MediaProfiles::createDefaultCamcorderTimeLapse480pProfile(camcorder_quality quality) 705{ 706 MediaProfiles::VideoCodec *videoCodec = 707 new MediaProfiles::VideoCodec(VIDEO_ENCODER_H263, 20000000, 720, 480, 20); 708 709 AudioCodec *audioCodec = new AudioCodec(AUDIO_ENCODER_AMR_NB, 12200, 8000, 1); 710 CamcorderProfile *profile = new MediaProfiles::CamcorderProfile; 711 profile->mCameraId = 0; 712 profile->mFileFormat = OUTPUT_FORMAT_THREE_GPP; 713 profile->mQuality = quality; 714 profile->mDuration = 60; 715 profile->mVideoCodec = videoCodec; 716 profile->mAudioCodec = audioCodec; 717 return profile; 718} 719 720/*static*/ void 721MediaProfiles::createDefaultCamcorderTimeLapseLowProfiles( 722 MediaProfiles::CamcorderProfile **lowTimeLapseProfile, 723 MediaProfiles::CamcorderProfile **lowSpecificTimeLapseProfile) { 724 *lowTimeLapseProfile = createDefaultCamcorderTimeLapseQcifProfile(CAMCORDER_QUALITY_TIME_LAPSE_LOW); 725 *lowSpecificTimeLapseProfile = createDefaultCamcorderTimeLapseQcifProfile(CAMCORDER_QUALITY_TIME_LAPSE_QCIF); 726} 727 728/*static*/ void 729MediaProfiles::createDefaultCamcorderTimeLapseHighProfiles( 730 MediaProfiles::CamcorderProfile **highTimeLapseProfile, 731 MediaProfiles::CamcorderProfile **highSpecificTimeLapseProfile) { 732 *highTimeLapseProfile = createDefaultCamcorderTimeLapse480pProfile(CAMCORDER_QUALITY_TIME_LAPSE_HIGH); 733 *highSpecificTimeLapseProfile = createDefaultCamcorderTimeLapse480pProfile(CAMCORDER_QUALITY_TIME_LAPSE_480P); 734} 735 736/*static*/ MediaProfiles::CamcorderProfile* 737MediaProfiles::createDefaultCamcorderQcifProfile(camcorder_quality quality) 738{ 739 MediaProfiles::VideoCodec *videoCodec = 740 new MediaProfiles::VideoCodec(VIDEO_ENCODER_H263, 192000, 176, 144, 20); 741 742 MediaProfiles::AudioCodec *audioCodec = 743 new MediaProfiles::AudioCodec(AUDIO_ENCODER_AMR_NB, 12200, 8000, 1); 744 745 MediaProfiles::CamcorderProfile *profile = new MediaProfiles::CamcorderProfile; 746 profile->mCameraId = 0; 747 profile->mFileFormat = OUTPUT_FORMAT_THREE_GPP; 748 profile->mQuality = quality; 749 profile->mDuration = 30; 750 profile->mVideoCodec = videoCodec; 751 profile->mAudioCodec = audioCodec; 752 return profile; 753} 754 755/*static*/ MediaProfiles::CamcorderProfile* 756MediaProfiles::createDefaultCamcorderCifProfile(camcorder_quality quality) 757{ 758 MediaProfiles::VideoCodec *videoCodec = 759 new MediaProfiles::VideoCodec(VIDEO_ENCODER_H263, 360000, 352, 288, 20); 760 761 AudioCodec *audioCodec = new AudioCodec(AUDIO_ENCODER_AMR_NB, 12200, 8000, 1); 762 CamcorderProfile *profile = new MediaProfiles::CamcorderProfile; 763 profile->mCameraId = 0; 764 profile->mFileFormat = OUTPUT_FORMAT_THREE_GPP; 765 profile->mQuality = quality; 766 profile->mDuration = 60; 767 profile->mVideoCodec = videoCodec; 768 profile->mAudioCodec = audioCodec; 769 return profile; 770} 771 772/*static*/ void 773MediaProfiles::createDefaultCamcorderLowProfiles( 774 MediaProfiles::CamcorderProfile **lowProfile, 775 MediaProfiles::CamcorderProfile **lowSpecificProfile) { 776 *lowProfile = createDefaultCamcorderQcifProfile(CAMCORDER_QUALITY_LOW); 777 *lowSpecificProfile = createDefaultCamcorderQcifProfile(CAMCORDER_QUALITY_QCIF); 778} 779 780/*static*/ void 781MediaProfiles::createDefaultCamcorderHighProfiles( 782 MediaProfiles::CamcorderProfile **highProfile, 783 MediaProfiles::CamcorderProfile **highSpecificProfile) { 784 *highProfile = createDefaultCamcorderCifProfile(CAMCORDER_QUALITY_HIGH); 785 *highSpecificProfile = createDefaultCamcorderCifProfile(CAMCORDER_QUALITY_CIF); 786} 787 788/*static*/ void 789MediaProfiles::createDefaultCamcorderProfiles(MediaProfiles *profiles) 790{ 791 // low camcorder profiles. 792 MediaProfiles::CamcorderProfile *lowProfile, *lowSpecificProfile; 793 createDefaultCamcorderLowProfiles(&lowProfile, &lowSpecificProfile); 794 profiles->mCamcorderProfiles.add(lowProfile); 795 profiles->mCamcorderProfiles.add(lowSpecificProfile); 796 797 // high camcorder profiles. 798 MediaProfiles::CamcorderProfile* highProfile, *highSpecificProfile; 799 createDefaultCamcorderHighProfiles(&highProfile, &highSpecificProfile); 800 profiles->mCamcorderProfiles.add(highProfile); 801 profiles->mCamcorderProfiles.add(highSpecificProfile); 802 803 // low camcorder time lapse profiles. 804 MediaProfiles::CamcorderProfile *lowTimeLapseProfile, *lowSpecificTimeLapseProfile; 805 createDefaultCamcorderTimeLapseLowProfiles(&lowTimeLapseProfile, &lowSpecificTimeLapseProfile); 806 profiles->mCamcorderProfiles.add(lowTimeLapseProfile); 807 profiles->mCamcorderProfiles.add(lowSpecificTimeLapseProfile); 808 809 // high camcorder time lapse profiles. 810 MediaProfiles::CamcorderProfile *highTimeLapseProfile, *highSpecificTimeLapseProfile; 811 createDefaultCamcorderTimeLapseHighProfiles(&highTimeLapseProfile, &highSpecificTimeLapseProfile); 812 profiles->mCamcorderProfiles.add(highTimeLapseProfile); 813 profiles->mCamcorderProfiles.add(highSpecificTimeLapseProfile); 814 815 // For emulator and other legacy devices which does not have a 816 // media_profiles.xml file, We assume that the default camera id 817 // is 0 and that is the only camera available. 818 profiles->mCameraIds.push(0); 819} 820 821/*static*/ void 822MediaProfiles::createDefaultAudioEncoders(MediaProfiles *profiles) 823{ 824 profiles->mAudioEncoders.add(createDefaultAmrNBEncoderCap()); 825} 826 827/*static*/ void 828MediaProfiles::createDefaultVideoDecoders(MediaProfiles *profiles) 829{ 830 MediaProfiles::VideoDecoderCap *cap = 831 new MediaProfiles::VideoDecoderCap(VIDEO_DECODER_WMV); 832 833 profiles->mVideoDecoders.add(cap); 834} 835 836/*static*/ void 837MediaProfiles::createDefaultAudioDecoders(MediaProfiles *profiles) 838{ 839 MediaProfiles::AudioDecoderCap *cap = 840 new MediaProfiles::AudioDecoderCap(AUDIO_DECODER_WMA); 841 842 profiles->mAudioDecoders.add(cap); 843} 844 845/*static*/ void 846MediaProfiles::createDefaultEncoderOutputFileFormats(MediaProfiles *profiles) 847{ 848 profiles->mEncoderOutputFileFormats.add(OUTPUT_FORMAT_THREE_GPP); 849 profiles->mEncoderOutputFileFormats.add(OUTPUT_FORMAT_MPEG_4); 850} 851 852/*static*/ MediaProfiles::AudioEncoderCap* 853MediaProfiles::createDefaultAmrNBEncoderCap() 854{ 855 return new MediaProfiles::AudioEncoderCap( 856 AUDIO_ENCODER_AMR_NB, 5525, 12200, 8000, 8000, 1, 1); 857} 858 859/*static*/ void 860MediaProfiles::createDefaultImageEncodingQualityLevels(MediaProfiles *profiles) 861{ 862 ImageEncodingQualityLevels *levels = new ImageEncodingQualityLevels(); 863 levels->mCameraId = 0; 864 levels->mLevels.add(70); 865 levels->mLevels.add(80); 866 levels->mLevels.add(90); 867 profiles->mImageEncodingQualityLevels.add(levels); 868} 869 870/*static*/ void 871MediaProfiles::createDefaultVideoEditorCap(MediaProfiles *profiles) 872{ 873 profiles->mVideoEditorCap = 874 new MediaProfiles::VideoEditorCap( 875 VIDEOEDITOR_DEFAULT_MAX_INPUT_FRAME_WIDTH, 876 VIDEOEDITOR_DEFUALT_MAX_INPUT_FRAME_HEIGHT, 877 VIDEOEDITOR_DEFAULT_MAX_OUTPUT_FRAME_WIDTH, 878 VIDEOEDITOR_DEFUALT_MAX_OUTPUT_FRAME_HEIGHT, 879 VIDEOEDITOR_DEFAULT_MAX_PREFETCH_YUV_FRAMES); 880} 881/*static*/ void 882MediaProfiles::createDefaultExportVideoProfiles(MediaProfiles *profiles) 883{ 884 // Create default video export profiles 885 profiles->mVideoEditorExportProfiles.add( 886 new ExportVideoProfile(VIDEO_ENCODER_H263, 887 OMX_VIDEO_H263ProfileBaseline, OMX_VIDEO_H263Level10)); 888 profiles->mVideoEditorExportProfiles.add( 889 new ExportVideoProfile(VIDEO_ENCODER_MPEG_4_SP, 890 OMX_VIDEO_MPEG4ProfileSimple, OMX_VIDEO_MPEG4Level1)); 891 profiles->mVideoEditorExportProfiles.add( 892 new ExportVideoProfile(VIDEO_ENCODER_H264, 893 OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel13)); 894} 895 896/*static*/ MediaProfiles* 897MediaProfiles::createDefaultInstance() 898{ 899 MediaProfiles *profiles = new MediaProfiles; 900 createDefaultCamcorderProfiles(profiles); 901 createDefaultVideoEncoders(profiles); 902 createDefaultAudioEncoders(profiles); 903 createDefaultVideoDecoders(profiles); 904 createDefaultAudioDecoders(profiles); 905 createDefaultEncoderOutputFileFormats(profiles); 906 createDefaultImageEncodingQualityLevels(profiles); 907 createDefaultVideoEditorCap(profiles); 908 createDefaultExportVideoProfiles(profiles); 909 return profiles; 910} 911 912/*static*/ MediaProfiles* 913MediaProfiles::createInstanceFromXmlFile(const char *xml) 914{ 915 FILE *fp = NULL; 916 CHECK((fp = fopen(xml, "r"))); 917 918 XML_Parser parser = ::XML_ParserCreate(NULL); 919 CHECK(parser != NULL); 920 921 MediaProfiles *profiles = new MediaProfiles(); 922 ::XML_SetUserData(parser, profiles); 923 ::XML_SetElementHandler(parser, startElementHandler, NULL); 924 925 /* 926 FIXME: 927 expat is not compiled with -DXML_DTD. We don't have DTD parsing support. 928 929 if (!::XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS)) { 930 ALOGE("failed to enable DTD support in the xml file"); 931 return UNKNOWN_ERROR; 932 } 933 934 */ 935 936 const int BUFF_SIZE = 512; 937 for (;;) { 938 void *buff = ::XML_GetBuffer(parser, BUFF_SIZE); 939 if (buff == NULL) { 940 ALOGE("failed to in call to XML_GetBuffer()"); 941 delete profiles; 942 profiles = NULL; 943 goto exit; 944 } 945 946 int bytes_read = ::fread(buff, 1, BUFF_SIZE, fp); 947 if (bytes_read < 0) { 948 ALOGE("failed in call to read"); 949 delete profiles; 950 profiles = NULL; 951 goto exit; 952 } 953 954 CHECK(::XML_ParseBuffer(parser, bytes_read, bytes_read == 0)); 955 956 if (bytes_read == 0) break; // done parsing the xml file 957 } 958 959exit: 960 ::XML_ParserFree(parser); 961 ::fclose(fp); 962 return profiles; 963} 964 965Vector<output_format> MediaProfiles::getOutputFileFormats() const 966{ 967 return mEncoderOutputFileFormats; // copy out 968} 969 970Vector<video_encoder> MediaProfiles::getVideoEncoders() const 971{ 972 Vector<video_encoder> encoders; 973 for (size_t i = 0; i < mVideoEncoders.size(); ++i) { 974 encoders.add(mVideoEncoders[i]->mCodec); 975 } 976 return encoders; // copy out 977} 978 979int MediaProfiles::getVideoEncoderParamByName(const char *name, video_encoder codec) const 980{ 981 ALOGV("getVideoEncoderParamByName: %s for codec %d", name, codec); 982 int index = -1; 983 for (size_t i = 0, n = mVideoEncoders.size(); i < n; ++i) { 984 if (mVideoEncoders[i]->mCodec == codec) { 985 index = i; 986 break; 987 } 988 } 989 if (index == -1) { 990 ALOGE("The given video encoder %d is not found", codec); 991 return -1; 992 } 993 994 if (!strcmp("enc.vid.width.min", name)) return mVideoEncoders[index]->mMinFrameWidth; 995 if (!strcmp("enc.vid.width.max", name)) return mVideoEncoders[index]->mMaxFrameWidth; 996 if (!strcmp("enc.vid.height.min", name)) return mVideoEncoders[index]->mMinFrameHeight; 997 if (!strcmp("enc.vid.height.max", name)) return mVideoEncoders[index]->mMaxFrameHeight; 998 if (!strcmp("enc.vid.bps.min", name)) return mVideoEncoders[index]->mMinBitRate; 999 if (!strcmp("enc.vid.bps.max", name)) return mVideoEncoders[index]->mMaxBitRate; 1000 if (!strcmp("enc.vid.fps.min", name)) return mVideoEncoders[index]->mMinFrameRate; 1001 if (!strcmp("enc.vid.fps.max", name)) return mVideoEncoders[index]->mMaxFrameRate; 1002 1003 ALOGE("The given video encoder param name %s is not found", name); 1004 return -1; 1005} 1006int MediaProfiles::getVideoEditorExportParamByName( 1007 const char *name, int codec) const 1008{ 1009 ALOGV("getVideoEditorExportParamByName: name %s codec %d", name, codec); 1010 ExportVideoProfile *exportProfile = NULL; 1011 int index = -1; 1012 for (size_t i =0; i < mVideoEditorExportProfiles.size(); i++) { 1013 exportProfile = mVideoEditorExportProfiles[i]; 1014 if (exportProfile->mCodec == codec) { 1015 index = i; 1016 break; 1017 } 1018 } 1019 if (index == -1) { 1020 ALOGE("The given video decoder %d is not found", codec); 1021 return -1; 1022 } 1023 if (!strcmp("videoeditor.export.profile", name)) 1024 return exportProfile->mProfile; 1025 if (!strcmp("videoeditor.export.level", name)) 1026 return exportProfile->mLevel; 1027 1028 ALOGE("The given video editor export param name %s is not found", name); 1029 return -1; 1030} 1031int MediaProfiles::getVideoEditorCapParamByName(const char *name) const 1032{ 1033 ALOGV("getVideoEditorCapParamByName: %s", name); 1034 1035 if (mVideoEditorCap == NULL) { 1036 ALOGE("The mVideoEditorCap is not created, then create default cap."); 1037 createDefaultVideoEditorCap(sInstance); 1038 } 1039 1040 if (!strcmp("videoeditor.input.width.max", name)) 1041 return mVideoEditorCap->mMaxInputFrameWidth; 1042 if (!strcmp("videoeditor.input.height.max", name)) 1043 return mVideoEditorCap->mMaxInputFrameHeight; 1044 if (!strcmp("videoeditor.output.width.max", name)) 1045 return mVideoEditorCap->mMaxOutputFrameWidth; 1046 if (!strcmp("videoeditor.output.height.max", name)) 1047 return mVideoEditorCap->mMaxOutputFrameHeight; 1048 if (!strcmp("maxPrefetchYUVFrames", name)) 1049 return mVideoEditorCap->mMaxPrefetchYUVFrames; 1050 1051 ALOGE("The given video editor param name %s is not found", name); 1052 return -1; 1053} 1054 1055Vector<audio_encoder> MediaProfiles::getAudioEncoders() const 1056{ 1057 Vector<audio_encoder> encoders; 1058 for (size_t i = 0; i < mAudioEncoders.size(); ++i) { 1059 encoders.add(mAudioEncoders[i]->mCodec); 1060 } 1061 return encoders; // copy out 1062} 1063 1064int MediaProfiles::getAudioEncoderParamByName(const char *name, audio_encoder codec) const 1065{ 1066 ALOGV("getAudioEncoderParamByName: %s for codec %d", name, codec); 1067 int index = -1; 1068 for (size_t i = 0, n = mAudioEncoders.size(); i < n; ++i) { 1069 if (mAudioEncoders[i]->mCodec == codec) { 1070 index = i; 1071 break; 1072 } 1073 } 1074 if (index == -1) { 1075 ALOGE("The given audio encoder %d is not found", codec); 1076 return -1; 1077 } 1078 1079 if (!strcmp("enc.aud.ch.min", name)) return mAudioEncoders[index]->mMinChannels; 1080 if (!strcmp("enc.aud.ch.max", name)) return mAudioEncoders[index]->mMaxChannels; 1081 if (!strcmp("enc.aud.bps.min", name)) return mAudioEncoders[index]->mMinBitRate; 1082 if (!strcmp("enc.aud.bps.max", name)) return mAudioEncoders[index]->mMaxBitRate; 1083 if (!strcmp("enc.aud.hz.min", name)) return mAudioEncoders[index]->mMinSampleRate; 1084 if (!strcmp("enc.aud.hz.max", name)) return mAudioEncoders[index]->mMaxSampleRate; 1085 1086 ALOGE("The given audio encoder param name %s is not found", name); 1087 return -1; 1088} 1089 1090Vector<video_decoder> MediaProfiles::getVideoDecoders() const 1091{ 1092 Vector<video_decoder> decoders; 1093 for (size_t i = 0; i < mVideoDecoders.size(); ++i) { 1094 decoders.add(mVideoDecoders[i]->mCodec); 1095 } 1096 return decoders; // copy out 1097} 1098 1099Vector<audio_decoder> MediaProfiles::getAudioDecoders() const 1100{ 1101 Vector<audio_decoder> decoders; 1102 for (size_t i = 0; i < mAudioDecoders.size(); ++i) { 1103 decoders.add(mAudioDecoders[i]->mCodec); 1104 } 1105 return decoders; // copy out 1106} 1107 1108int MediaProfiles::getCamcorderProfileIndex(int cameraId, camcorder_quality quality) const 1109{ 1110 int index = -1; 1111 for (size_t i = 0, n = mCamcorderProfiles.size(); i < n; ++i) { 1112 if (mCamcorderProfiles[i]->mCameraId == cameraId && 1113 mCamcorderProfiles[i]->mQuality == quality) { 1114 index = i; 1115 break; 1116 } 1117 } 1118 return index; 1119} 1120 1121int MediaProfiles::getCamcorderProfileParamByName(const char *name, 1122 int cameraId, 1123 camcorder_quality quality) const 1124{ 1125 ALOGV("getCamcorderProfileParamByName: %s for camera %d, quality %d", 1126 name, cameraId, quality); 1127 1128 int index = getCamcorderProfileIndex(cameraId, quality); 1129 if (index == -1) { 1130 ALOGE("The given camcorder profile camera %d quality %d is not found", 1131 cameraId, quality); 1132 return -1; 1133 } 1134 1135 if (!strcmp("duration", name)) return mCamcorderProfiles[index]->mDuration; 1136 if (!strcmp("file.format", name)) return mCamcorderProfiles[index]->mFileFormat; 1137 if (!strcmp("vid.codec", name)) return mCamcorderProfiles[index]->mVideoCodec->mCodec; 1138 if (!strcmp("vid.width", name)) return mCamcorderProfiles[index]->mVideoCodec->mFrameWidth; 1139 if (!strcmp("vid.height", name)) return mCamcorderProfiles[index]->mVideoCodec->mFrameHeight; 1140 if (!strcmp("vid.bps", name)) return mCamcorderProfiles[index]->mVideoCodec->mBitRate; 1141 if (!strcmp("vid.fps", name)) return mCamcorderProfiles[index]->mVideoCodec->mFrameRate; 1142 if (!strcmp("aud.codec", name)) return mCamcorderProfiles[index]->mAudioCodec->mCodec; 1143 if (!strcmp("aud.bps", name)) return mCamcorderProfiles[index]->mAudioCodec->mBitRate; 1144 if (!strcmp("aud.ch", name)) return mCamcorderProfiles[index]->mAudioCodec->mChannels; 1145 if (!strcmp("aud.hz", name)) return mCamcorderProfiles[index]->mAudioCodec->mSampleRate; 1146 1147 ALOGE("The given camcorder profile param id %d name %s is not found", cameraId, name); 1148 return -1; 1149} 1150 1151bool MediaProfiles::hasCamcorderProfile(int cameraId, camcorder_quality quality) const 1152{ 1153 return (getCamcorderProfileIndex(cameraId, quality) != -1); 1154} 1155 1156Vector<int> MediaProfiles::getImageEncodingQualityLevels(int cameraId) const 1157{ 1158 Vector<int> result; 1159 ImageEncodingQualityLevels *levels = findImageEncodingQualityLevels(cameraId); 1160 if (levels != NULL) { 1161 result = levels->mLevels; // copy out 1162 } 1163 return result; 1164} 1165 1166int MediaProfiles::getStartTimeOffsetMs(int cameraId) const { 1167 int offsetTimeMs = -1; 1168 ssize_t index = mStartTimeOffsets.indexOfKey(cameraId); 1169 if (index >= 0) { 1170 offsetTimeMs = mStartTimeOffsets.valueFor(cameraId); 1171 } 1172 ALOGV("offsetTime=%d ms and cameraId=%d", offsetTimeMs, cameraId); 1173 return offsetTimeMs; 1174} 1175 1176MediaProfiles::~MediaProfiles() 1177{ 1178 CHECK("destructor should never be called" == 0); 1179#if 0 1180 for (size_t i = 0; i < mAudioEncoders.size(); ++i) { 1181 delete mAudioEncoders[i]; 1182 } 1183 mAudioEncoders.clear(); 1184 1185 for (size_t i = 0; i < mVideoEncoders.size(); ++i) { 1186 delete mVideoEncoders[i]; 1187 } 1188 mVideoEncoders.clear(); 1189 1190 for (size_t i = 0; i < mVideoDecoders.size(); ++i) { 1191 delete mVideoDecoders[i]; 1192 } 1193 mVideoDecoders.clear(); 1194 1195 for (size_t i = 0; i < mAudioDecoders.size(); ++i) { 1196 delete mAudioDecoders[i]; 1197 } 1198 mAudioDecoders.clear(); 1199 1200 for (size_t i = 0; i < mCamcorderProfiles.size(); ++i) { 1201 delete mCamcorderProfiles[i]; 1202 } 1203 mCamcorderProfiles.clear(); 1204#endif 1205} 1206} // namespace android 1207