fuquan/android_mt6572_jiabo
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
android_mt6572_jiabo/hardware/ti/omap4/test/VTC/VTCTestApp.cpp
FuQuan 3ff2876a30 first commit
2025-09-05 16:56:03 +08:00

1560 lines
54 KiB
C++
Raw Permalink Blame History

/*
* Copyright (C) Texas Instruments - http://www.ti.com/
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#define LOG_NDEBUG 0
#define LOG_TAG "VTCTest"
#include <fcntl.h>
#include <getopt.h>
#include <stdlib.h>
#include <unistd.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <time.h>
#include <semaphore.h>
#include <pthread.h>
#include <binder/IPCThreadState.h>
#include <binder/ProcessState.h>
#include <binder/IServiceManager.h>
#include <camera/Camera.h>
#include <camera/ICamera.h>
#include <system/audio.h>
#include <cutils/log.h>
#include <media/mediaplayer.h>
#include <media/mediarecorder.h>
#include <media/stagefright/OMXClient.h>
#include <media/stagefright/OMXCodec.h>
#include <media/stagefright/MediaDefs.h>
#ifdef ANDROID_API_JB_OR_LATER
#include <media/stagefright/foundation/ADebug.h>
#else
#include <media/stagefright/MediaDebug.h>
#endif
#include <media/stagefright/MPEG4Writer.h>
#include <media/stagefright/CameraSource.h>
#include <media/stagefright/MetaData.h>
#ifdef ANDROID_API_JB_OR_LATER
#include <gui/Surface.h>
#include <gui/ISurface.h>
#include <gui/ISurfaceComposer.h>
#include <gui/ISurfaceComposerClient.h>
#include <gui/SurfaceComposerClient.h>
#else
#include <surfaceflinger/Surface.h>
#include <surfaceflinger/ISurface.h>
#include <surfaceflinger/ISurfaceComposer.h>
#include <surfaceflinger/ISurfaceComposerClient.h>
#include <surfaceflinger/SurfaceComposerClient.h>
#endif
#include <cutils/properties.h>
#include "OMX_TI_Index.h"
#include "OMX_TI_Video.h"
#include "VtcCommon.h"
#define SLEEP_AFTER_STARTING_PREVIEW 3
#define SLEEP_AFTER_STARTING_PLAYBACK 5
#define WIDTH 1280
#define HEIGHT 720
using namespace android;
int mMediaServerPID = -1;
int mStartMemory = 0;
int mTestCount = 0;
int mFailCount = 0;
int filename = 0;
int mDuration = 10;
int mPlaybackDuration = 0;
int testcase = 1;
int InsertIDRFrameEveryXSecs = 1;
int mPreviewWidth = WIDTH;
int mPreviewHeight = HEIGHT;
int mOutputFd = -1;
int camera_index = 0;
int mSliceSizeBytes = 500;
int mSliceSizeMB = 100;
int mDisable1080pTesting = 0;
int mRobustnessTestType = -1;
bool mIsSizeInBytes = true;
bool mCameraThrewError = false;
bool mMediaPlayerThrewError = false;
char mParamValue[100];
char mRecordFileName[256];
char mPlaybackFileName[256];
FILE *mResultsFP = NULL;
// If seconds < 0, only the first frame is I frame, and rest are all P frames
// If seconds == 0, all frames are encoded as I frames. No P frames
// If seconds > 0, it is the time spacing (seconds) between 2 neighboring I frames
int32_t mIFramesIntervalSec = 1;
uint32_t mVideoBitRate = 1000000;
uint32_t mVideoFrameRate = 30;
uint32_t mNewVideoBitRate = 100000;
uint32_t mNewVideoFrameRate = 15;
uint32_t mCycles = 10;
sp<Camera> camera;
sp<SurfaceComposerClient> client;
sp<SurfaceControl> surfaceControl;
sp<Surface> previewSurface;
CameraParameters params;
sp<MediaRecorder> recorder;
sp<MediaPlayer> player;
sp<SurfaceComposerClient> playbackComposerClient;
sp<SurfaceControl> playbackSurfaceControl;
sp<Surface> playbackSurface;
//To perform better
static pthread_cond_t mCond;
static pthread_mutex_t mMutex;
bool bPlaying = false;
bool bRecording = false;
uint32_t cameraWinX = 0;
uint32_t cameraWinY = 0;
uint32_t playerWinX = 0;
uint32_t playerWinY = 0;
uint32_t cameraSurfaceWidth = 0;
uint32_t cameraSurfaceHeight = 0;
uint32_t playbackSurfaceWidth = 400;
uint32_t playbackSurfaceHeight = 400;
//forward declarations
int test_ALL();
int test_DEFAULT();
int test_InsertIDRFrames();
int test_MaxNALSize();
int test_ChangeBitRate();
int test_ChangeFrameRate();
int test_PlaybackAndRecord_sidebyside();
int test_PlaybackAndRecord_PIP();
int test_PlaybackOnly();
int test_Robust();
typedef int (*pt2TestFunction)();
pt2TestFunction TestFunctions[10] = {
test_ALL, // 0
test_DEFAULT, // 1
test_InsertIDRFrames, // 2
test_MaxNALSize, // 3
test_ChangeBitRate, // 4
test_ChangeFrameRate, // 5
test_PlaybackAndRecord_sidebyside, // 6
test_PlaybackAndRecord_PIP, // 7
test_PlaybackOnly, // 8
test_Robust // 9
};
class MyCameraListener: public CameraListener {
public:
virtual void notify(int32_t msgType, int32_t ext1, int32_t /* ext2 */) {
VTC_LOGD("\n\n\n notifynotifynotifynotifynotifynotifynotifyCamera reported an error!!!\n\n\n");
if ( msgType & CAMERA_MSG_ERROR && (ext1 == 1)) {
VTC_LOGD("\n\n\n Camera reported an error!!!\n\n\n");
mCameraThrewError = true;
pthread_cond_signal(&mCond);
}
}
virtual void postData(int32_t /* msgType */,
const sp<IMemory>& /* dataPtr */,
camera_frame_metadata_t * /* metadata */){}
virtual void postDataTimestamp(nsecs_t /* timestamp */, int32_t /* msgType */, const sp<IMemory>& /* dataPtr */){}
};
sp<MyCameraListener> mCameraListener;
class PlayerListener: public MediaPlayerListener {
public:
virtual void notify(int msg, int ext1, int ext2, const Parcel * /* obj */)
{
VTC_LOGD("Notify cb: %d %d %d\n", msg, ext1, ext2);
if ( msg == MEDIA_PREPARED ){
VTC_LOGD("MEDIA_PREPARED!");
player->start();
}
if ( msg == MEDIA_SET_VIDEO_SIZE ){
VTC_LOGD("MEDIA_SET_VIDEO_SIZE!");
}
if ( msg == MEDIA_PLAYBACK_COMPLETE ){
VTC_LOGD("MEDIA_PLAYBACK_COMPLETE!");
pthread_cond_signal(&mCond);
}
if ( msg == MEDIA_ERROR ){
VTC_LOGD("PLAYER REPORTED MEDIA_ERROR!");
mMediaPlayerThrewError = true;
pthread_cond_signal(&mCond);
}
}
};
sp<PlayerListener> mPlayerListener;
int getMediaserverInfo(int *PID, int *VSIZE){
FILE *fp;
char ps_output[256];
/* Open the command for reading. */
fp = popen("ps mediaserver", "r");
if (fp == NULL) {
VTC_LOGE("Failed to get mediaserver pid !!!" );
return -1;
}
/* Read the output a line at a time. We need the last line.*/
while (fgets(ps_output, sizeof(ps_output)-1, fp) != NULL) {}
char *substring;
substring = strtok (ps_output," "); // first is the USER name
substring = strtok (NULL, " "); // second is the PID
*PID = atoi(substring);
substring = strtok (NULL, " "); // third is the PPID
substring = strtok (NULL, " "); // fourth is the VSIZE
*VSIZE = atoi(substring);
pclose(fp);
return 0;
}
int my_pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t * mutex, int waitTimeInMilliSecs) {
if (waitTimeInMilliSecs == 0)
{
return pthread_cond_wait(cond, mutex);
}
struct timespec ts;
clock_gettime(CLOCK_REALTIME, &ts);
if (waitTimeInMilliSecs >= 1000) { // > 1 sec
ts.tv_sec += (waitTimeInMilliSecs/1000);
} else {
ts.tv_nsec += waitTimeInMilliSecs * 1000000;
}
return pthread_cond_timedwait(cond, mutex, &ts);
}
int startPlayback() {
#ifdef ANDROID_API_JB_MR1_OR_LATER
playbackSurfaceControl = playbackComposerClient->createSurface(String8(), playbackSurfaceWidth, playbackSurfaceHeight, PIXEL_FORMAT_RGB_565);
#else
playbackSurfaceControl = playbackComposerClient->createSurface(0, playbackSurfaceWidth, playbackSurfaceHeight, PIXEL_FORMAT_RGB_565);
#endif
CHECK(playbackSurfaceControl != NULL);
CHECK(playbackSurfaceControl->isValid());
playbackSurface = playbackSurfaceControl->getSurface();
CHECK(playbackSurface != NULL);
playbackComposerClient->openGlobalTransaction();
playbackSurfaceControl->setLayer(0x7fffffff);
playbackSurfaceControl->setPosition(playerWinX, playerWinY);
playbackSurfaceControl->setSize(playbackSurfaceWidth, playbackSurfaceHeight);
playbackSurfaceControl->show();
playbackComposerClient->closeGlobalTransaction();
player = new MediaPlayer();
mPlayerListener = new PlayerListener();
mMediaPlayerThrewError = false;
player->setListener(mPlayerListener);
player->setDataSource(mPlaybackFileName, NULL);
player->setVideoSurfaceTexture(playbackSurface->getSurfaceTexture());
player->prepareAsync();
bPlaying = true;
return 0;
}
int stopPlayback() {
VTC_LOGD("%d: %s", __LINE__, __FUNCTION__);
player->stop();
player->setListener(0);
player->disconnect();
player.clear();
mPlayerListener.clear();
if ( NULL != playbackSurface.get() ) {
playbackSurface.clear();
}
if ( NULL != playbackSurfaceControl.get() ) {
playbackSurfaceControl->clear();
playbackSurfaceControl.clear();
}
if ( NULL != playbackComposerClient.get() ) {
playbackComposerClient->dispose();
playbackComposerClient.clear();
}
return 0;
}
int verfiyByPlayback() {
VTC_LOGD(" ============= verfiyByPlayback ============= ");
playbackComposerClient = new SurfaceComposerClient();
CHECK_EQ(playbackComposerClient->initCheck(), (status_t)OK);
#ifdef ANDROID_API_JB_MR1_OR_LATER
DisplayInfo displayInfo;
playbackComposerClient->getDisplayInfo(0, &displayInfo);
playbackSurfaceWidth = displayInfo.w;
playbackSurfaceHeight = displayInfo.h;
#else
playbackSurfaceWidth = playbackComposerClient->getDisplayWidth(0);
playbackSurfaceHeight = playbackComposerClient->getDisplayHeight(0);
#endif
VTC_LOGD("Panel WxH = %d x %d", playbackSurfaceWidth, playbackSurfaceHeight);
startPlayback();
pthread_mutex_lock(&mMutex);
if (bPlaying){
pthread_cond_wait(&mCond, &mMutex);
}
pthread_mutex_unlock(&mMutex);
stopPlayback();
return 0;
}
int createPreviewSurface() {
client = new SurfaceComposerClient();
CHECK_EQ(client->initCheck(), (status_t)OK);
if ((cameraSurfaceWidth == 0) || (cameraSurfaceHeight == 0)){
#ifdef ANDROID_API_JB_MR1_OR_LATER
DisplayInfo displayInfo;
client->getDisplayInfo(0, &displayInfo);
cameraSurfaceWidth = displayInfo.w;
cameraSurfaceHeight = displayInfo.h;
#else
cameraSurfaceWidth = client->getDisplayWidth(0);
cameraSurfaceHeight = client->getDisplayHeight(0);
#endif
}
#ifdef ANDROID_API_JB_MR1_OR_LATER
surfaceControl = client->createSurface(String8(),
cameraSurfaceWidth,
cameraSurfaceHeight,
HAL_PIXEL_FORMAT_RGB_565);
#else
surfaceControl = client->createSurface(0,
cameraSurfaceWidth,
cameraSurfaceHeight,
HAL_PIXEL_FORMAT_RGB_565);
#endif
previewSurface = surfaceControl->getSurface();
client->openGlobalTransaction();
surfaceControl->setLayer(0x7fffffff);
surfaceControl->setPosition(cameraWinX, cameraWinY);
surfaceControl->setSize(cameraSurfaceWidth, cameraSurfaceHeight);
surfaceControl->show();
client->closeGlobalTransaction();
return 0;
}
int destroyPreviewSurface() {
if ( NULL != previewSurface.get() ) {
previewSurface.clear();
}
if ( NULL != surfaceControl.get() ) {
surfaceControl->clear();
surfaceControl.clear();
}
if ( NULL != client.get() ) {
client->dispose();
client.clear();
}
return 0;
}
int startRecording() {
if (camera.get() == NULL) return -1;
recorder = new MediaRecorder();
if ( NULL == recorder.get() ) {
VTC_LOGD("Error while creating MediaRecorder\n");
return -1;
}
camera->unlock();
if ( recorder->setCamera(camera->remote(), camera->getRecordingProxy()) < 0 ) {
VTC_LOGD("error while setting the camera\n");
return -1;
}
if ( recorder->setVideoSource(1 /*VIDEO_SOURCE_CAMERA*/) < 0 ) {
VTC_LOGD("error while configuring camera video source\n");
return -1;
}
if ( recorder->setAudioSource(AUDIO_SOURCE_DEFAULT) < 0 ) {
VTC_LOGD("error while configuring camera audio source\n");
return -1;
}
if ( recorder->setOutputFormat(OUTPUT_FORMAT_THREE_GPP) < 0 ) {
VTC_LOGD("error while configuring output format\n");
return -1;
}
if(mkdir("/mnt/sdcard/vtc_videos",0777) == -1)
VTC_LOGD("\n Directory \'vtc_videos\' was not created or maybe it was already created \n");
mOutputFd = open(mRecordFileName, O_CREAT | O_RDWR);
if(mOutputFd < 0){
VTC_LOGD("Error while creating video filename\n");
return -1;
}
if ( recorder->setOutputFile(mOutputFd, 0, 0) < 0 ) {
VTC_LOGD("error while configuring video filename\n");
return -1;
}
if ( recorder->setVideoFrameRate(mVideoFrameRate) < 0 ) {
VTC_LOGD("error while configuring video framerate\n");
return -1;
}
if ( recorder->setVideoSize(mPreviewWidth, mPreviewHeight) < 0 ) {
VTC_LOGD("error while configuring video size\n");
return -1;
}
if ( recorder->setVideoEncoder(VIDEO_ENCODER_H264) < 0 ) {
VTC_LOGD("error while configuring video codec\n");
return -1;
}
if ( recorder->setAudioEncoder(AUDIO_ENCODER_AMR_NB) < 0 ) {
VTC_LOGD("error while configuring audio codec\n");
return -1;
}
if ( recorder->setPreviewSurface(previewSurface) < 0 ) {
VTC_LOGD("error while configuring preview surface\n");
return -1;
}
sprintf(mParamValue,"video-param-encoding-bitrate=%u", mVideoBitRate);
String8 bit_rate(mParamValue);
if ( recorder->setParameters(bit_rate) < 0 ) {
VTC_LOGD("error while configuring bit rate\n");
return -1;
}
sprintf(mParamValue,"video-param-i-frames-interval=%u", mIFramesIntervalSec);
String8 interval(mParamValue);
if ( recorder->setParameters(interval) < 0 ) {
VTC_LOGD("error while configuring i-frame interval\n");
return -1;
}
if ( recorder->prepare() < 0 ) {
VTC_LOGD("recorder prepare failed\n");
return -1;
}
if ( recorder->start() < 0 ) {
VTC_LOGD("recorder start failed\n");
return -1;
}
bRecording = true;
return 0;
}
int stopRecording() {
VTC_LOGD("stopRecording()");
if (camera.get() == NULL) return -1;
if ( NULL == recorder.get() ) {
VTC_LOGD("invalid recorder reference\n");
return -1;
}
if ( recorder->stop() < 0 ) {
VTC_LOGD("recorder failed to stop\n");
return -1;
}
recorder->release();
recorder.clear();
if ( 0 < mOutputFd ) {
close(mOutputFd);
}
return 0;
}
int startPreview() {
char value[PROPERTY_VALUE_MAX];
property_get("disable.VSTAB.VNF", value, "0");
int disable_VTAB_and_VNF = atoi(value);
mCameraThrewError = false;
bRecording = false;
createPreviewSurface();
camera = Camera::connect(camera_index);
if (camera.get() == NULL){
VTC_LOGE("camera.get() =================== NULL");
return -1;
}
VTC_LOGD("\n\n mPreviewWidth = %d, mPreviewHeight = %d, mVideoFrameRate = %d, mVideoBitRate = %d \n\n\n",
mPreviewWidth, mPreviewHeight, mVideoFrameRate, mVideoBitRate);
params.unflatten(camera->getParameters());
params.setPreviewSize(mPreviewWidth, mPreviewHeight);
params.setPreviewFrameRate(mVideoFrameRate);
params.set(CameraParameters::KEY_RECORDING_HINT, CameraParameters::TRUE);// Set recording hint, otherwise it defaults to high-quality and there is not enough memory available to do playback and camera preview simultaneously!
sprintf(mParamValue,"%u,%u", mVideoFrameRate*1000, mVideoFrameRate*1000);
params.set("preview-fps-range", mParamValue);
if(disable_VTAB_and_VNF){
VTC_LOGI("\n\n\nDisabling VSTAB & VNF (noise reduction)\n\n");
params.set("vstab" , 0);
params.set("vnf", 0);
}
camera->setParameters(params.flatten());
camera->setPreviewDisplay(previewSurface);
mCameraListener = new MyCameraListener();
camera->setListener(mCameraListener);
VTC_LOGV("get(preview-fps-range) = %s", params.get("preview-fps-range"));
VTC_LOGV("get(preview-fps-range-values) = %s", params.get("preview-fps-range-values"));
VTC_LOGV("get(preview-size-values) = %s\n", params.get("preview-size-values"));
VTC_LOGV("get(preview-frame-rate-values) = %s", params.get("preview-frame-rate-values"));
camera->startPreview();
sleep(SLEEP_AFTER_STARTING_PREVIEW);
return 0;
}
void stopPreview() {
if (camera.get() == NULL) return;
camera->stopPreview();
camera->disconnect();
camera.clear();
mCameraListener.clear();
destroyPreviewSurface();
}
int test_DEFAULT() {
startPreview();
startRecording();
sleep(mDuration);
stopRecording();
stopPreview();
return 0;
}
int test_InsertIDRFrames() {
status_t err = 0;
mIFramesIntervalSec = 0;
startPreview();
startRecording();
int duration = 0;
while (duration < mDuration) {
sleep(InsertIDRFrameEveryXSecs);
duration += InsertIDRFrameEveryXSecs;
sprintf(mParamValue,"video-param-insert-i-frame=1");
String8 param(mParamValue);
err = recorder->setParameters(param);
if (err != OK) return -1;
VTC_LOGI("\n Inserted an IDR Frame. \n");
};
stopRecording();
stopPreview();
return 0;
}
int test_MaxNALSize() {
status_t err = 0;
if (mIsSizeInBytes) {
//Testing size base on bytes
CHECK(mPreviewWidth > 320);
CHECK(mSliceSizeBytes >= 256);
} else {
//Testing size base on MB
CHECK(mSliceSizeMB > 6);
CHECK(mSliceSizeMB < (((mPreviewWidth+15)>> 4) * ((mPreviewHeight+15)>> 4)));
/* Max # of MB
1080p=8160
720p=3600
VGA=1200
*/
}
/* Other limitations:
4. Input content type should be progressive
6. Changing parameters at run time will not have effect until next I-frame.
7. Incase of doing the initial setting of nPFrames = 0 (only initial frame is I-frame and all others P-frames),
you must request an I-frame to the codec after you have set nSlicesize to see your changes take place.
*/
mIFramesIntervalSec = 0; //may be needed. dont know for sure. if it is not zero, then in OMXCodec, under support for B Frames, something is done.
startPreview();
startRecording();
if (mIsSizeInBytes) {
sprintf(mParamValue,"video-param-nalsize-bytes=%u", mSliceSizeBytes);
String8 param(mParamValue);
err = recorder->setParameters(param);
if (err != OK) return -1;
VTC_LOGI("\n Set the Slice Size in bytes.\n");
} else {
sprintf(mParamValue,"video-param-nalsize-macroblocks=%u", mSliceSizeMB);
String8 param(mParamValue);
err = recorder->setParameters(param);
if (err != OK) return -1;
VTC_LOGI("\n Set the Slice Size in MB\n");
}
// Change won't take effect until next IFrame. So, force an IFrame.
sprintf(mParamValue,"video-param-insert-i-frame=1");
String8 paramI(mParamValue);
err = recorder->setParameters(paramI);
if (err != OK) return -1;
VTC_LOGI("\n Inserted an IDR Frame. \n");
sleep(mDuration);
stopRecording();
stopPreview();
mIFramesIntervalSec = 1;
return 0;
}
int test_ChangeBitRate() {
startPreview();
startRecording();
sleep(mDuration/2);
sprintf(mParamValue,"video-config-encoding-bitrate=%u", mNewVideoBitRate);
String8 param(mParamValue);
status_t err = recorder->setParameters(param);
if (err != OK) return -1;
VTC_LOGI("\n\nSet new bitrate. \n\n");
sleep(mDuration/2);
stopRecording();
stopPreview();
return 0;
}
int test_ChangeFrameRate() {
startPreview();
startRecording();
sleep(mDuration/2);
// Changing the framerate in camera.
params.unflatten(camera->getParameters());
VTC_LOGD("Setting new framerate: %d", mNewVideoFrameRate);
sprintf(mParamValue,"%u,%u", mNewVideoFrameRate*1000, mNewVideoFrameRate*1000);
params.set("preview-fps-range", mParamValue);
VTC_LOGD("get(preview-fps-range) = %s", params.get("preview-fps-range"));
camera->setParameters(params.flatten());
// Changing the framerate in encoder.
sprintf(mParamValue,"video-config-encoding-framerate=%u", mNewVideoFrameRate);
String8 param(mParamValue);
status_t err = recorder->setParameters(param);
if (err != OK) return -1;
VTC_LOGI("\n\nSet new framerate. \n\n");
sleep(mDuration/2);
stopRecording();
stopPreview();
return 0;
}
int test_PlaybackAndRecord_sidebyside() {
playbackComposerClient = new SurfaceComposerClient();
CHECK_EQ(playbackComposerClient->initCheck(), (status_t)OK);
#ifdef ANDROID_API_JB_MR1_OR_LATER
DisplayInfo displayInfo;
playbackComposerClient->getDisplayInfo(0, &displayInfo);
int panelwidth = displayInfo.w;
int panelheight = displayInfo.h;
#else
int panelwidth = playbackComposerClient->getDisplayWidth(0);
int panelheight = playbackComposerClient->getDisplayHeight(0);
#endif
VTC_LOGD("Panel WxH = %d x %d", panelwidth, panelheight);
if (panelwidth < panelheight) {//Portrait Phone
VTC_LOGD("\nPortrait Device\n");
playbackSurfaceWidth = panelwidth;
playbackSurfaceHeight = panelheight/2;
playerWinX = 0;
playerWinY = 0;
cameraWinX = 0;
cameraWinY = playbackSurfaceHeight;
cameraSurfaceWidth = panelwidth;
cameraSurfaceHeight = panelheight/2;
} else {// Landscape
VTC_LOGD("\n Landscape Device\n");
playbackSurfaceWidth = panelwidth/2;
playbackSurfaceHeight = panelheight;
playerWinX = 0;
playerWinY = 0;
cameraWinX = playbackSurfaceWidth;
cameraWinY = 0;
cameraSurfaceWidth = panelwidth/2;
cameraSurfaceHeight = panelheight;
}
startPlayback();
sleep(SLEEP_AFTER_STARTING_PLAYBACK);
startPreview();
startRecording();
pthread_mutex_lock(&mMutex);
if (bPlaying && bRecording && !mMediaPlayerThrewError){
my_pthread_cond_timedwait(&mCond, &mMutex, mPlaybackDuration);
}
pthread_mutex_unlock(&mMutex);
stopRecording();
stopPreview();
stopPlayback();
cameraWinX = 0;
cameraWinY = 0;
playerWinX = 0;
playerWinY = 0;
return 0;
}
int test_PlaybackAndRecord_PIP() {
playbackComposerClient = new SurfaceComposerClient();
CHECK_EQ(playbackComposerClient->initCheck(), (status_t)OK);
#ifdef ANDROID_API_JB_MR1_OR_LATER
DisplayInfo displayInfo;
playbackComposerClient->getDisplayInfo(0, &displayInfo);
uint32_t panelwidth = displayInfo.w;
uint32_t panelheight = displayInfo.h;
#else
uint32_t panelwidth = playbackComposerClient->getDisplayWidth(0);
uint32_t panelheight = playbackComposerClient->getDisplayHeight(0);
#endif
VTC_LOGD("Panel WxH = %d x %d", panelwidth, panelheight);
if (panelwidth < panelheight) {//Portrait Phone
VTC_LOGD("\nPortrait Device\n");
playbackSurfaceWidth = panelwidth;
playbackSurfaceHeight = panelheight;
playerWinX = 0;
playerWinY = 0;
cameraSurfaceWidth = panelwidth/2;
cameraSurfaceHeight = panelheight/4;
cameraWinX = (panelwidth - cameraSurfaceWidth) / 2;
cameraWinY = 0;
} else { // Landscape
VTC_LOGD("\n Landscape Device\n");
playbackSurfaceWidth = panelwidth;
playbackSurfaceHeight = panelheight;
playerWinX = 0;
playerWinY = 0;
cameraSurfaceWidth = panelwidth/3;
cameraSurfaceHeight = panelheight/3;
cameraWinX = ((panelwidth - cameraSurfaceWidth) / 2) + panelwidth/4;
cameraWinY = 0;
}
startPlayback();
sleep(SLEEP_AFTER_STARTING_PLAYBACK);
startPreview();
startRecording();
while (bPlaying && bRecording && !mMediaPlayerThrewError) {
int rc;
pthread_mutex_lock(&mMutex);
rc = my_pthread_cond_timedwait(&mCond, &mMutex, 100);
pthread_mutex_unlock(&mMutex);
if (rc != ETIMEDOUT){
break; //exit while loop
}
/* Move preview */
cameraWinY +=2;
if ((cameraWinY+ cameraSurfaceHeight) > panelheight) cameraWinY = 0;
client->openGlobalTransaction();
surfaceControl->setPosition(cameraWinX, cameraWinY);
client->closeGlobalTransaction();
if (cameraWinY > cameraSurfaceHeight/2){
client->openGlobalTransaction();
surfaceControl->hide();
client->closeGlobalTransaction();
} else {
client->openGlobalTransaction();
surfaceControl->show();
client->closeGlobalTransaction();
}
};
stopRecording();
stopPreview();
stopPlayback();
cameraWinX = 0;
cameraWinY = 0;
playerWinX = 0;
playerWinY = 0;
return 0;
}
int test_PlaybackOnly()
{
playbackComposerClient = new SurfaceComposerClient();
CHECK_EQ(playbackComposerClient->initCheck(), (status_t)OK);
#ifdef ANDROID_API_JB_MR1_OR_LATER
DisplayInfo displayInfo;
playbackComposerClient->getDisplayInfo(0, &displayInfo);
int panelwidth = displayInfo.w;
int panelheight = displayInfo.h;
#else
int panelwidth = playbackComposerClient->getDisplayWidth(0);
int panelheight = playbackComposerClient->getDisplayHeight(0);
#endif
VTC_LOGD("Panel WxH = %d x %d", panelwidth, panelheight);
if (panelwidth < panelheight) {//Portrait Phone
VTC_LOGD("\nPortrait Device\n");
playbackSurfaceWidth = panelwidth;
playbackSurfaceHeight = panelheight/2;
playerWinX = 0;
playerWinY = 0;
cameraWinX = 0;
cameraWinY = playbackSurfaceHeight;
cameraSurfaceWidth = panelwidth;
cameraSurfaceHeight = panelheight/2;
} else {// Landscape
VTC_LOGD("\n Landscape Device\n");
playbackSurfaceWidth = panelwidth;
playbackSurfaceHeight = panelheight;
playerWinX = 0;
playerWinY = 0;
}
startPlayback();
pthread_mutex_lock(&mMutex);
if (bPlaying){
my_pthread_cond_timedwait(&mCond, &mMutex, mPlaybackDuration);
}
pthread_mutex_unlock(&mMutex);
stopPlayback();
playerWinX = 0;
playerWinY = 0;
return 0;
}
void updatePassRate(int test_status, bool verifyRecordedClip) {
mTestCount++;
if (verifyRecordedClip){
sleep(2);
strcpy(mPlaybackFileName, mRecordFileName);
verfiyByPlayback();
}
// Wait for 10 seconds to make sure the memory settle.
VTC_LOGD("%d: %s: Evaluating test results. Looking for memory leak. Waiting for memory to settle down ....", __LINE__, __FUNCTION__);
sleep(10);
int currentMediaServerPID;
int endMemory;
getMediaserverInfo(&currentMediaServerPID, &endMemory);
int memDiff = endMemory - mStartMemory;
if (memDiff < 0) {
memDiff = 0;
}
VTC_LOGD("\n\n======================= Memory Leak [in bytes] = %d =======================\n\n", memDiff);sleep(1);
int old_mFailCount = mFailCount;
if (mMediaPlayerThrewError) mFailCount++;
else if (mCameraThrewError) mFailCount++;
else if (bPlaying == false) mFailCount++;
else if (bRecording == false) mFailCount++;
else if (test_status != 0) mFailCount++;
else if (mMediaServerPID != currentMediaServerPID) mFailCount++; //implies mediaserver crashed. So, increment failure count.
else if (memDiff > 10000) mFailCount++; //implies memory leak. So, increment failure count.
VTC_LOGD("\n\nTest Results:\n\nNo. of Tests Executed = %d\nPASS = %d\nFAIL = %d\n\n", mTestCount, (mTestCount-mFailCount), (mFailCount*-1));
mResultsFP = fopen("/sdcard/VTC_TEST_RESULTS.TXT", "a");
if (mResultsFP != NULL) {
if (old_mFailCount != mFailCount)
fprintf(mResultsFP, "%03d\tFAIL\t[%s]\n", mTestCount, mRecordFileName);
else fprintf(mResultsFP, "%03d\tPASS\t[%s]\n", mTestCount, mRecordFileName);
fclose(mResultsFP);
}
mMediaServerPID = currentMediaServerPID; //Initialize for next test
mStartMemory = endMemory; //I shouldn't be doing this right??
}
int test_Robust() {
int status = 0;
uint32_t cyclesCompleted = 0;
getMediaserverInfo(&mMediaServerPID, &mStartMemory);
if (mRobustnessTestType != -1){
if ((mRobustnessTestType >= 1) || (mRobustnessTestType <= 8)) {
for ( cyclesCompleted = 0; cyclesCompleted < mCycles; cyclesCompleted++){
VTC_LOGD("\n\n\n############################ Iteration: %d. Goal: %d ############################\n\n\n", cyclesCompleted, mCycles);
status = TestFunctions[mRobustnessTestType]();
updatePassRate(status, false);
}
}
return 0;
}
sprintf(mRecordFileName, "/mnt/sdcard/vtc_videos/UTR_0039_Robustness_last_recorded.3gp");
VTC_LOGD("\n\n################################## Recording. Filename: %s\n\n", mRecordFileName);
// Each cycle will play a selected number of different resolution scenarios
// Starting from low to high resolution
for ( cyclesCompleted = 0; cyclesCompleted < mCycles; cyclesCompleted++){
VTC_LOGD("\n\n\n############################ Iteration: %d. Goal: %d ############################\n\n\n", cyclesCompleted, mCycles);
mVideoBitRate = 3000000;
mVideoFrameRate = 30;
sprintf(mPlaybackFileName, "/mnt/ext_sdcard/vtc_playback/AV_000249_H264_VGA_1Mbps_eAACplus_48khz_64kbps.mp4");
mPreviewWidth = 640;
mPreviewHeight = 480;
status = test_PlaybackAndRecord_sidebyside();
updatePassRate(status, false);
sprintf(mPlaybackFileName, "/mnt/ext_sdcard/vtc_playback/AV-720p-JamesBond.MP4");
mPreviewWidth = 1280;
mPreviewHeight = 720;
status = test_PlaybackAndRecord_sidebyside();
updatePassRate(status, false);
}
return 0;
}
int test_ALL()
{
// Automated Unit Test suite
VTC_LOGD("\n\nExecuting %s \n\n", __FUNCTION__);
int status = 0;
char value[PROPERTY_VALUE_MAX];
getMediaserverInfo(&mMediaServerPID, &mStartMemory);
mDuration = 10;
mResultsFP = fopen("/sdcard/VTC_TEST_RESULTS.TXT", "w+"); // To create a new file each time
fclose(mResultsFP);
property_get("disable.1080p.testing", value, "0");
mDisable1080pTesting = atoi(value);
if(mDisable1080pTesting){
VTC_LOGD("\n\n\n\n######## 1080p Testing as been disable #######\n\n\n");
}
if(!mDisable1080pTesting){
sprintf(mRecordFileName, "/mnt/sdcard/vtc_videos/UTR_%03d_1080p_30fps_1Mbps_i-frame-2sec.3gp", mTestCount);
VTC_LOGD("\n\n###################################################### Recording. Filename: %s\n\n", mRecordFileName);
mPreviewWidth = 1920;
mPreviewHeight = 1080;
mIFramesIntervalSec = 2;
status = test_DEFAULT();
updatePassRate(status, true);
sprintf(mRecordFileName, "/mnt/sdcard/vtc_videos/UTR_%03d_1080p_30fps_1Mbps_i-frame-10sec.3gp", mTestCount);
VTC_LOGD("\n\n###################################################### Recording. Filename: %s\n\n", mRecordFileName);
mPreviewWidth = 1920;
mPreviewHeight = 1080;
mIFramesIntervalSec = 10;
mDuration = 30;
status = test_DEFAULT();
updatePassRate(status, true);
sprintf(mRecordFileName, "/mnt/sdcard/vtc_videos/UTR_%03d_1080p_30fps_1Mbps_i-frame-0sec.3gp", mTestCount);
VTC_LOGD("\n\n###################################################### Recording. Filename: %s\n\n", mRecordFileName);
mPreviewWidth = 1920;
mPreviewHeight = 1080;
mIFramesIntervalSec = 0;
status = test_DEFAULT();
updatePassRate(status, true);
}
sprintf(mRecordFileName, "/mnt/sdcard/vtc_videos/UTR_%03d_720p_30fps_1Mbps_i-frame-3sec.3gp", mTestCount);
VTC_LOGD("\n\n###################################################### Recording. Filename: %s\n\n", mRecordFileName);
mPreviewWidth = 1280;
mPreviewHeight = 720;
mIFramesIntervalSec = 3;
status = test_DEFAULT();
updatePassRate(status, true);
sprintf(mRecordFileName, "/mnt/sdcard/vtc_videos/UTR_%03d_720p_30fps_1Mbps_i-frame-8sec.3gp", mTestCount);
VTC_LOGD("\n\n###################################################### Recording. Filename: %s\n\n", mRecordFileName);
mPreviewWidth = 1280;
mPreviewHeight = 720;
mIFramesIntervalSec = 8;
status = test_DEFAULT();
updatePassRate(status, true);
sprintf(mRecordFileName, "/mnt/sdcard/vtc_videos/UTR_%03d_720p_30fps_1Mbps_i-frame-0sec.3gp", mTestCount);
VTC_LOGD("\n\n###################################################### Recording. Filename: %s\n\n", mRecordFileName);
mPreviewWidth = 1280;
mPreviewHeight = 720;
mIFramesIntervalSec = 0;
status = test_DEFAULT();
updatePassRate(status, true);
sprintf(mRecordFileName, "/mnt/sdcard/vtc_videos/UTR_%03d_VGA_30fps_1Mbps_i-frame-1sec.3gp", mTestCount);
VTC_LOGD("\n\n###################################################### Recording. Filename: %s\n\n", mRecordFileName);
mPreviewWidth = 640;
mPreviewHeight = 480;
mIFramesIntervalSec = 1;
status = test_DEFAULT();
updatePassRate(status, true);
sprintf(mRecordFileName, "/mnt/sdcard/vtc_videos/UTR_%03d_VGA_30fps_1Mbps_i-frame-15sec.3gp", mTestCount);
VTC_LOGD("\n\n###################################################### Recording. Filename: %s\n\n", mRecordFileName);
mPreviewWidth = 640;
mPreviewHeight = 480;
mIFramesIntervalSec = 15;
mDuration = 30;
status = test_DEFAULT();
updatePassRate(status, true);
sprintf(mRecordFileName, "/mnt/sdcard/vtc_videos/UTR_%03d_VGA_30fps_1Mbps_i-frame-0sec.3gp", mTestCount);
VTC_LOGD("\n\n###################################################### Recording. Filename: %s\n\n", mRecordFileName);
mPreviewWidth = 640;
mPreviewHeight = 480;
mIFramesIntervalSec = 0;
status = test_DEFAULT();
updatePassRate(status, true);
if(!mDisable1080pTesting){
sprintf(mRecordFileName, "/mnt/sdcard/vtc_videos/UTR_%03d_1080p_1Mbps_30fps-15fps.3gp", mTestCount);
VTC_LOGD("\n\n###################################################### Recording. Filename: %s\n\n", mRecordFileName);
mPreviewWidth = 1920;
mPreviewHeight = 1080;
mVideoFrameRate = 30;
mNewVideoFrameRate = 15;
status = test_ChangeFrameRate();
updatePassRate(status, true);
sprintf(mRecordFileName, "/mnt/sdcard/vtc_videos/UTR_%03d_1080p_1Mbps_15fps-30fps.3gp", mTestCount);
VTC_LOGD("\n\n###################################################### Recording. Filename: %s\n\n", mRecordFileName);
mPreviewWidth = 1920;
mPreviewHeight = 1080;
mVideoFrameRate = 15;
mNewVideoFrameRate = 30;
status = test_ChangeFrameRate();
updatePassRate(status, true);
sprintf(mRecordFileName, "/mnt/sdcard/vtc_videos/UTR_%03d_1080p_1Mbps_30fps-24fps.3gp", mTestCount);
VTC_LOGD("\n\n###################################################### Recording. Filename: %s\n\n", mRecordFileName);
mPreviewWidth = 1920;
mPreviewHeight = 1080;
mVideoFrameRate = 30;
mNewVideoFrameRate = 24;
status = test_ChangeFrameRate();
updatePassRate(status, true);
}
sprintf(mRecordFileName, "/mnt/sdcard/vtc_videos/UTR_%03d_720p_1Mbps_30fps-15fps.3gp", mTestCount);
VTC_LOGD("\n\n###################################################### Recording. Filename: %s\n\n", mRecordFileName);
mPreviewWidth = 1280;
mPreviewHeight = 720;
mVideoFrameRate = 30;
mNewVideoFrameRate = 15;
status = test_ChangeFrameRate();
updatePassRate(status, true);
sprintf(mRecordFileName, "/mnt/sdcard/vtc_videos/UTR_%03d_720p_1Mbps_15fps-30fps.3gp", mTestCount);
VTC_LOGD("\n\n###################################################### Recording. Filename: %s\n\n", mRecordFileName);
mPreviewWidth = 1280;
mPreviewHeight = 720;
mVideoFrameRate = 30;
mNewVideoFrameRate = 24;
status = test_ChangeFrameRate();
updatePassRate(status, true);
sprintf(mRecordFileName, "/mnt/sdcard/vtc_videos/UTR_%03d_720p_1Mbps_24fps-30fps.3gp", mTestCount);
VTC_LOGD("\n\n###################################################### Recording. Filename: %s\n\n", mRecordFileName);
mPreviewWidth = 1280;
mPreviewHeight = 720;
mVideoFrameRate = 15;
mNewVideoFrameRate = 30;
status = test_ChangeFrameRate();
updatePassRate(status, true);
sprintf(mRecordFileName, "/mnt/sdcard/vtc_videos/UTR_%03d_VGA_1Mbps_30fps-15fps.3gp", mTestCount);
VTC_LOGD("\n\n###################################################### Recording. Filename: %s\n\n", mRecordFileName);
mPreviewWidth = 640;
mPreviewHeight = 480;
mVideoFrameRate = 30;
mNewVideoFrameRate = 15;
status = test_ChangeFrameRate();
updatePassRate(status, true);
sprintf(mRecordFileName, "/mnt/sdcard/vtc_videos/UTR_%03d_VGA_1Mbps_15fps-30fps.3gp", mTestCount);
VTC_LOGD("\n\n###################################################### Recording. Filename: %s\n\n", mRecordFileName);
mPreviewWidth = 640;
mPreviewHeight = 480;
mVideoFrameRate = 30;
mNewVideoFrameRate = 24;
status = test_ChangeFrameRate();
updatePassRate(status, true);
sprintf(mRecordFileName, "/mnt/sdcard/vtc_videos/UTR_%03d_VGA_1Mbps_24fps-30fps.3gp", mTestCount);
VTC_LOGD("\n\n###################################################### Recording. Filename: %s\n\n", mRecordFileName);
mPreviewWidth = 640;
mPreviewHeight = 480;
mVideoFrameRate = 24;
mNewVideoFrameRate = 30;
status = test_ChangeFrameRate();
updatePassRate(status, true);
if(!mDisable1080pTesting){
sprintf(mRecordFileName, "/mnt/sdcard/vtc_videos/UTR_%03d_1080p_30fps_1Mbps_max-1000MB.3gp", mTestCount);
VTC_LOGD("\n\n###################################################### Recording. Filename: %s\n\n", mRecordFileName);
mPreviewWidth = 1920;
mPreviewHeight = 1080;
mVideoFrameRate = 30;
mIsSizeInBytes = false;
mSliceSizeMB = 1000;
status = test_MaxNALSize();
updatePassRate(status, true);
}
sprintf(mRecordFileName, "/mnt/sdcard/vtc_videos/UTR_%03d_720p_30fps_1Mbps_max-300MB.3gp", mTestCount);
VTC_LOGD("\n\n###################################################### Recording. Filename: %s\n\n", mRecordFileName);
mPreviewWidth = 1280;
mPreviewHeight = 720;
mIsSizeInBytes = false;
mSliceSizeMB = 300;
status = test_MaxNALSize();
updatePassRate(status, true);
sprintf(mRecordFileName, "/mnt/sdcard/vtc_videos/UTR_%03d_VGAp_30fps_1Mbps_max-8MB.3gp", mTestCount);
VTC_LOGD("\n\n###################################################### Recording. Filename: %s\n\n", mRecordFileName);
mPreviewWidth = 640;
mPreviewHeight = 480;
mIsSizeInBytes = false;
mSliceSizeMB = 8;
status = test_MaxNALSize();
updatePassRate(status, true);
if(!mDisable1080pTesting){
sprintf(mRecordFileName, "/mnt/sdcard/vtc_videos/UTR_%03d_1080p_30fps_1Mbps_i-frames_every-2sec.3gp", mTestCount);
VTC_LOGD("\n\n###################################################### Recording. Filename: %s\n\n", mRecordFileName);
mPreviewWidth = 1920;
mPreviewHeight = 1080;
InsertIDRFrameEveryXSecs = 2;
status = test_InsertIDRFrames();
updatePassRate(status, true);
}
sprintf(mRecordFileName, "/mnt/sdcard/vtc_videos/UTR_%03d_720p_30fps_1Mbps_i-frames_every-5sec.3gp", mTestCount);
VTC_LOGD("\n\n###################################################### Recording. Filename: %s\n\n", mRecordFileName);
mPreviewWidth = 1280;
mPreviewHeight = 720;
InsertIDRFrameEveryXSecs = 5;
status = test_InsertIDRFrames();
updatePassRate(status, true);
sprintf(mRecordFileName, "/mnt/sdcard/vtc_videos/UTR_%03d_VGA_30fps_1Mbps_i-frames_every-8.3gp", mTestCount);
VTC_LOGD("\n\n###################################################### Recording. Filename: %s\n\n", mRecordFileName);
mPreviewWidth = 640;
mPreviewHeight = 480;
InsertIDRFrameEveryXSecs = 8;
mDuration = 20;
status = test_InsertIDRFrames();
updatePassRate(status, true);
if(!mDisable1080pTesting){
sprintf(mRecordFileName, "/mnt/sdcard/vtc_videos/UTR_%03d_1080p_30fps_1Mbps_max-1000bytes.3gp", mTestCount);
VTC_LOGD("\n\n###################################################### Recording. Filename: %s\n\n", mRecordFileName);
mPreviewWidth = 1920;
mPreviewHeight = 1080;
mIsSizeInBytes = true;
mSliceSizeBytes = 1000;
mVideoBitRate = 1000000;
mVideoFrameRate = 30;
status = test_MaxNALSize();
updatePassRate(status, true);
}
sprintf(mRecordFileName, "/mnt/sdcard/vtc_videos/UTR_%03d_720p_30fps_1Mbps_max-500bytes.3gp", mTestCount);
VTC_LOGD("\n\n###################################################### Recording. Filename: %s\n\n", mRecordFileName);
mPreviewWidth = 1280;
mPreviewHeight = 720;
mIsSizeInBytes = true;
mSliceSizeBytes = 500;
mVideoBitRate = 1000000;
mVideoFrameRate = 30;
status = test_MaxNALSize();
updatePassRate(status, true);
sprintf(mRecordFileName, "/mnt/sdcard/vtc_videos/UTR_%03d_VGA_30fps_1Mbps_max-256bytes.3gp", mTestCount);
VTC_LOGD("\n\n###################################################### Recording. Filename: %s\n\n", mRecordFileName);
mPreviewWidth = 640;
mPreviewHeight = 480;
mIsSizeInBytes = true;
mSliceSizeBytes = 256;
mVideoBitRate = 1000000;
mVideoFrameRate = 30;
status = test_MaxNALSize();
updatePassRate(status, true);
//PIP TC
sprintf(mRecordFileName, "/mnt/sdcard/vtc_videos/UTR_%03d_D1PAL_30fps_1Mbps_simultaneous.3gp", mTestCount);
sprintf(mPlaybackFileName, "/mnt/ext_sdcard/vtc_playback/AV_000795_H264_D1PAL_25fps_4Mbps_NB_AMR_8Khz_12.2Kbps.mp4");
VTC_LOGD("\n\n################################## Recording. Filename: %s\n\n", mRecordFileName);
VTC_LOGD("\n\n################################## Playing. Filename: %s\n\n", mPlaybackFileName);
mPreviewWidth = 720;
mPreviewHeight = 576;
mVideoBitRate = 1000000;
mVideoFrameRate = 30;
status = test_PlaybackAndRecord_sidebyside();
updatePassRate(status, true);
sprintf(mRecordFileName, "/mnt/sdcard/vtc_videos/UTR_%03d_D1PAL_30fps_1Mbps_PIP.3gp", mTestCount);
sprintf(mPlaybackFileName, "/mnt/ext_sdcard/vtc_playback/AV_000795_H264_D1PAL_25fps_4Mbps_NB_AMR_8Khz_12.2Kbps.mp4");
VTC_LOGD("\n\n################################## Recording. Filename: %s\n\n", mRecordFileName);
VTC_LOGD("\n\n################################## Playing. Filename: %s\n\n", mPlaybackFileName);
mPreviewWidth = 720;
mPreviewHeight = 576;
mVideoBitRate = 1000000;
mVideoFrameRate = 30;
status = test_PlaybackAndRecord_PIP();
updatePassRate(status, true);
//Simultaneous playback/record
sprintf(mRecordFileName, "/mnt/sdcard/vtc_videos/UTR_%03d_VGA_30fps_1Mbps_simultaneous.3gp", mTestCount);
sprintf(mPlaybackFileName, "/mnt/ext_sdcard/vtc_playback/AV_000249_H264_VGA_1Mbps_eAACplus_48khz_64kbps.mp4");
VTC_LOGD("\n\n################################## Recording. Filename: %s\n\n", mRecordFileName);
VTC_LOGD("\n\n################################## Playing. Filename: %s\n\n", mPlaybackFileName);
mPreviewWidth = 640;
mPreviewHeight = 480;
mVideoBitRate = 1000000;
mVideoFrameRate = 30;
status = test_PlaybackAndRecord_sidebyside();
updatePassRate(status, true);
sprintf(mRecordFileName, "/mnt/sdcard/vtc_videos/UTR_%03d_720p_24fps_1Mbps_simultaneous.3gp", mTestCount);
sprintf(mPlaybackFileName, "/mnt/ext_sdcard/vtc_playback/FinalFantasy13_720p_mono_3.8Mbps_27fps.MP4");
VTC_LOGD("\n\n################################## Recording. Filename: %s\n\n", mRecordFileName);
VTC_LOGD("\n\n################################## Playing. Filename: %s\n\n", mPlaybackFileName);
mPreviewWidth = 1280;
mPreviewHeight = 720;
mVideoBitRate = 1000000;
mVideoFrameRate = 24;
status = test_PlaybackAndRecord_sidebyside();
updatePassRate(status, true);
sprintf(mRecordFileName, "/mnt/sdcard/vtc_videos/UTR_%03d_720p_30fps_1Mbps_simultaneous.3gp", mTestCount);
sprintf(mPlaybackFileName, "/mnt/ext_sdcard/vtc_playback/AV-720p-JamesBond.MP4");
VTC_LOGD("\n\n################################## Recording. Filename: %s\n\n", mRecordFileName);
VTC_LOGD("\n\n################################## Playing. Filename: %s\n\n", mPlaybackFileName);
mPreviewWidth = 1280;
mPreviewHeight = 720;
mVideoBitRate = 1000000;
mVideoFrameRate = 30;
status = test_PlaybackAndRecord_sidebyside();
updatePassRate(status, true);
if(!mDisable1080pTesting){
sprintf(mRecordFileName, "/mnt/sdcard/vtc_videos/UTR_%03d_1080p_24fps_1Mbps_simultaneous.3gp", mTestCount);
sprintf(mPlaybackFileName, "/mnt/ext_sdcard/vtc_playback/AV_001181_Toy_Story3Official_Trailer_in_FullHD1080p_h264_BP_L4.0_1920x1080_24fps_1Mbps_eAACplus_44100Hz.mp4");
VTC_LOGD("\n\n################################## Recording. Filename: %s\n\n", mRecordFileName);
VTC_LOGD("\n\n################################## Playing. Filename: %s\n\n", mPlaybackFileName);
mPreviewWidth = 1920;
mPreviewHeight = 1080;
mVideoBitRate = 1000000;
mVideoFrameRate = 24;
status = test_PlaybackAndRecord_sidebyside();
updatePassRate(status, true);
sprintf(mRecordFileName, "/mnt/sdcard/vtc_videos/UTR_%03d_1080p_30fps_1Mbps_simultaneous.3gp", mTestCount);
sprintf(mPlaybackFileName, "/mnt/ext_sdcard/vtc_playback/AV_000858_FinalFantasy13_1080p_h264_bp_30fps_8mbps_aac_lc.mp4");
VTC_LOGD("\n\n################################## Recording. Filename: %s\n\n", mRecordFileName);
VTC_LOGD("\n\n################################## Playing. Filename: %s\n\n", mPlaybackFileName);
mPreviewWidth = 1920;
mPreviewHeight = 1080;
mVideoBitRate = 1000000;
mVideoFrameRate = 30;
status = test_PlaybackAndRecord_sidebyside();
updatePassRate(status, true);
}
sprintf(mRecordFileName, "/mnt/sdcard/vtc_videos/UTR_%03d_QQVGA_15fps_bps_i-frames_every-8.3gp", mTestCount);
VTC_LOGD("\n\n###################################################### Recording. Filename: %s\n\n", mRecordFileName);
mPreviewWidth = 160;
mPreviewHeight = 120;
mDuration = 10;
mVideoBitRate = 262144;
mVideoFrameRate = 15;
status = test_DEFAULT();
updatePassRate(status, true);
//Framerate and Bitrate change TC done, set default
mVideoFrameRate = 30;
mVideoBitRate = 1000000;
if(!mDisable1080pTesting){
sprintf(mRecordFileName, "/mnt/sdcard/vtc_videos/UTR_%03d1_1080p_30fps_from-5Mbps-to-100kbps.3gp", mTestCount);
VTC_LOGD("\n\n###################################################### Recording. Filename: %s\n\n", mRecordFileName);
mPreviewWidth = 1920;
mPreviewHeight = 1080;
mNewVideoBitRate = 100000;
mVideoBitRate = 5000000;
status = test_ChangeBitRate();
updatePassRate(status, true);
}
sprintf(mRecordFileName, "/mnt/sdcard/vtc_videos/UTR_%03d_720p_30fps_from-5Mbps-to-100kbps.3gp", mTestCount);
VTC_LOGD("\n\n###################################################### Recording. Filename: %s\n\n", mRecordFileName);
mPreviewWidth = 1280;
mPreviewHeight = 720;
mNewVideoBitRate = 100000;
mVideoBitRate = 5000000;
status = test_ChangeBitRate();
updatePassRate(status, true);
sprintf(mRecordFileName, "/mnt/sdcard/vtc_videos/UTR_%03d_VGA_30fps_from-5Mbps-to-100kbps.3gp", mTestCount);
VTC_LOGD("\n\n###################################################### Recording. Filename: %s\n\n", mRecordFileName);
mPreviewWidth = 640;
mPreviewHeight = 480;
mNewVideoBitRate = 50000;
mVideoBitRate = 1000000;
status = test_ChangeBitRate();
updatePassRate(status, true);
//Bit rate change TC done, set default
mVideoBitRate = 1000000;
///////////////////////////// END of Unit Test /////////////////////////////////////////
VTC_LOGD("\n\nTest Results:\n\nNo. of Tests = %d\nPASS = %d\nFAIL = %d\n\n", mTestCount, (mTestCount-mFailCount), (mFailCount*-1));
char results[256];
mResultsFP = fopen("/sdcard/VTC_TEST_RESULTS.TXT", "r");
if (mResultsFP != NULL) {
while( fgets(results, sizeof(results), mResultsFP) != NULL ) VTC_LOGD("%s", results);
fclose(mResultsFP);
}
return 0;
}
void printUsage() {
printf("\n\nApplication for testing VTC requirements");
printf("\nUsage: /system/bin/VTCTestApp test_case_id");
printf("\n\n\nTest Case ID can be any of the following");
printf("\n0 - Runs all the tests listed in the UTR. Pass/Fail must be determined by the tester after examining the recorded clips.");
printf("\n1 - Default test case. Does not require any parameters to be set.");
printf("\n2 - Tests the ability to request I-Frame generation real time. Option: -I");
printf("\n3 - Tests the ability to specify the maximum allowed frame size. Option: -s");
printf("\n4 - Tests the ability to change the bitrate at runtime. Option: -B");
printf("\n5 - Tests the ability to change the framerate at runtime. Option: -F");
printf("\n6 - Test Playback and Record. Option: -p, -n");
printf("\n7 - Test PIP. Option: -p, -n");
printf("\n8 - Test Video playback Only. Option: -p");
printf("\n9 - Robustness. Default: play and record the predefined resolutions (VGA & 720p). Option: -c, -v");
printf("\n\n\nAvailable Options:");
printf("\n-n: Record Filename(/mnt/sdcard/vtc_videos/video_0.3gp) is appended with this number. Default = %d", filename);
printf("\n-w: Preview/Record Width. Default = %d", mPreviewWidth);
printf("\n-h: Preview/Record Height. Default = %d", mPreviewHeight);
printf("\n-d: Recording time in secs. Default = %d seconds", mDuration);
printf("\n-i: I Frame Interval in secs. Default = %d", mIFramesIntervalSec);
printf("\n-s: Slice Size bytes. Default = %d", mSliceSizeBytes);
printf("\n-M: Slice Size Macroblocks. Default = %d", mSliceSizeMB);
printf("\n-b: Bitrate. Default = %d", mVideoBitRate);
printf("\n-f: Framerate. Default = %d", mVideoFrameRate);
printf("\n-I: Insert I Frames. Specify the period in secs. Default = %d second", InsertIDRFrameEveryXSecs);
printf("\n-B: Change bitrate at runtime to this new value. Default = %d", mNewVideoBitRate);
printf("\n-F: Change framerate at runtime to this new value. Default = %d", mNewVideoFrameRate);
printf("\n-p: Playback Filename. Default = %s", mPlaybackFileName);
printf("\n-c: Robustness, number of cycles. Default = %d", mCycles);
printf("\n-v: Robustness. Which test to repeat? Range: 1-8. Read test descriptions above. Default = -1 = play and record the predefined resolutions (VGA & 720p)");
printf("\n-t: Playback Duration in milli secs. Default = %d = Play till EOF", mPlaybackDuration);
printf("\n\n\n");
}
int main (int argc, char* argv[]) {
sp<ProcessState> proc(ProcessState::self());
ProcessState::self()->startThreadPool();
pthread_mutex_init(&mMutex, NULL);
pthread_cond_init(&mCond, NULL);
int opt;
const char* const short_options = "n:w:h:d:s:i:I:b:f:B:F:p:M:c:t:v:";
const struct option long_options[] = {
{"record_filename", 1, NULL, 'n'},
{"width", 1, NULL, 'w'},
{"height", 1, NULL, 'h'},
{"record_duration", 1, NULL, 'd'},
{"slice_size_bytes", 1, NULL, 's'},
{"i_frame_interval", 1, NULL, 'i'},
{"insert_I_frames", 1, NULL, 'I'},
{"bitrate", 1, NULL, 'b'},
{"new_bitrate", 1, NULL, 'B'},
{"framerate", 1, NULL, 'f'},
{"new_framerate", 1, NULL, 'F'},
{"playback_filename", 1, NULL, 'p'},
{"slice_size_MB", 1, NULL, 'M'},
{"num_cycles", 1, NULL, 'c'},
{"playback_duration", 1, NULL, 't'},
{"robustness_test_type", 1, NULL, 'v'},
{NULL, 0, NULL, 0}
};
sprintf(mPlaybackFileName, "/sdcard/nasa.mp4");
if (argc < 2){
printUsage();
return 0;
}
testcase = atoi(argv[1]);
while((opt = getopt_long(argc, argv, short_options, long_options, NULL)) != -1) {
switch(opt) {
case 'n':
filename = atoi(optarg);
break;
case 'w':
mPreviewWidth = atoi(optarg);
break;
case 'h':
mPreviewHeight = atoi(optarg);
break;
case 'd':
mDuration = atoi(optarg);
break;
case 's':
mSliceSizeBytes = atoi(optarg);
mIsSizeInBytes = true;
break;
case 'b':
mVideoBitRate = atoi(optarg);
break;
case 'B':
mNewVideoBitRate = atoi(optarg);
break;
case 'f':
mVideoFrameRate = atoi(optarg);
break;
case 'F':
mNewVideoFrameRate = atoi(optarg);
break;
case 'i':
mIFramesIntervalSec = atoi(optarg);
break;
case 'I':
InsertIDRFrameEveryXSecs = atoi(optarg);
break;
case 'p':
strcpy(mPlaybackFileName, optarg);
VTC_LOGD("Playback clip %s", mPlaybackFileName);
break;
case 'M':
mSliceSizeMB = atoi(optarg);
mIsSizeInBytes = false;
break;
case 'c':
mCycles = atoi(optarg);
break;
case 't':
mPlaybackDuration = atoi(optarg);
break;
case 'v':
mRobustnessTestType = atoi(optarg);
break;
case ':':
VTC_LOGE("\nError - Option `%c' needs a value\n\n", optopt);
return -1;
case '?':
VTC_LOGE("\nError - No such option: `%c'\n\n", optopt);
return -1;
}
}
sprintf(mRecordFileName, "/mnt/sdcard/vtc_videos/video_%d.3gp", filename);
VTC_LOGI("\n\nRecorded Output is stored in %s\n\n", mRecordFileName);
system("echo VTCTestApp > /sys/power/wake_lock");
TestFunctions[testcase]();
system("echo VTCTestApp > /sys/power/wake_unlock");
pthread_mutex_destroy(&mMutex);
pthread_cond_destroy(&mCond);
return 0;
}
Reference in a new issue View git blame Copy permalink