commit code coverage for video encoder libmix
BZ:62190
btest is special developed for code coverage tesing toward to libintelmetadatabuffer.
mix_encoder is special developed for code coverage test toward to libmix.
Commit them to mainline branch to keep.
Adjusting code style.
Signed-off-by: Liu Bolun <bolunx.liu@intel.com>
Change-Id: Iecc22aec29ea5e84747f566a55fd2a7f3a1a1677
Reviewed-on: http://android.intel.com:8080/70007
Reviewed-by: Liu, BolunX <bolunx.liu@intel.com>
Reviewed-by: Shi, PingX <pingx.shi@intel.com>
Tested-by: Shi, PingX <pingx.shi@intel.com>
Reviewed-by: buildbot <buildbot@intel.com>
Tested-by: buildbot <buildbot@intel.com>
diff --git a/test/btest.cpp b/test/btest.cpp
index 13b790b..32f34a8 100644
--- a/test/btest.cpp
+++ b/test/btest.cpp
@@ -33,10 +33,13 @@
mb1 = new IntelMetadataBuffer();
ret = mb1->SetType(t1);
ret = mb1->SetValue(v1);
+ mb1->GetMaxBufferSize();
if (t1 != MetadataBufferTypeGrallocSource) {
ret = mb1->SetValueInfo(&vi1);
ret = mb1->SetExtraValues(ev1, 10);
+ ret = mb1->SetExtraValues(ev1, 10);
}
+// ret = mb1->GetBytes(bytes, size);
ret = mb1->Serialize(bytes, size);
printf("assembling IntelMetadataBuffer %s, ret = %d\n", (ret == IMB_SUCCESS)?"Success":"Fail", ret );
@@ -48,14 +51,28 @@
printf("\n");
mb2 = new IntelMetadataBuffer();
+// ret = mb2->SetBytes(bytes, size);
ret = mb2->UnSerialize(bytes, size);
printf("parsing IntelMetadataBuffer %s, ret = %d\n", (ret == IMB_SUCCESS)?"Success":"Fail", ret );
ret = mb2->GetType(t2);
ret = mb2->GetValue(v2);
ret = mb2->GetValueInfo(vi2);
+ ret = mb1->SetExtraValues(ev1, 10);
ret = mb2->GetExtraValues(ev2, count);
+ IntelMetadataBuffer mb3;;
+// mb3 = new IntelMetadataBuffer();
+ ret = mb3.SetType(t1);
+ ret = mb3.SetValue(v1);
+ ret = mb3.SetExtraValues(ev1, 10);
+ ret = mb3.SetValueInfo(&vi1);
+ ret = mb3.UnSerialize(bytes, size);
+
+ IntelMetadataBuffer *mb4 = new IntelMetadataBuffer(mb3);
+ IntelMetadataBuffer *mb5;
+ mb5 = mb4;
+
printf("t2=%d, v2=%d, vi2=%x, ev2=%x\n", t2, v2, vi2, ev2);
if (v1 == v2 && t1 == t2 ) {
if (vi2) {
diff --git a/test/mix_encoder.cpp b/test/mix_encoder.cpp
index 5ec64b5..464b759 100644
--- a/test/mix_encoder.cpp
+++ b/test/mix_encoder.cpp
@@ -22,11 +22,23 @@
return -1; \
}
+#define CHECK_ENCODE_STATUS_RETURN(FUNC)\
+ if (ret != ENCODE_SUCCESS) { \
+ printf(FUNC"Failed. ret = 0x%08x\n", ret); \
+ return -1; \
+ }
+
static const char *AVC_MIME_TYPE = "video/h264";
static const char *MPEG4_MIME_TYPE = "video/mpeg4";
static const char *H263_MIME_TYPE = "video/h263";
+//add for video encode libmix code coverage test--start
+//add two mine type define only for code coverage test
+static const char *MPEG4_MIME_TYPE_SP= "video/mp4v-es";
+static const char *MEDIA_MIMETYPE_IMAGE_JPEG = "image/jpeg";
+//add for video encode libmix code coverage test--end
static const int box_width = 128;
+static VideoParamsAVC gVideoParamsAVC;
static IVideoEncoder *gVideoEncoder = NULL;
static VideoParamsCommon gEncoderParams;
static VideoParamsStoreMetaDataInBuffers gStoreMetaDataInBuffers;
@@ -51,9 +63,14 @@
static char* gFile = (char*)"out.264";
static uint32_t gMode = 0; //0:Camera malloc , 1: WiDi clone, 2: WiDi ext, 3: WiDi user, 4: Raw, 5: SurfaceMediaSource
-static const char* gModeString[7] = {"Camera malloc", "WiDi clone", "WiDi ext", "WiDi user", "Raw", "GrallocSource(Composer)", "GrallocSource(Gralloc)"};
+static const char* gModeString[9] = {"Camera malloc", "WiDi clone", "WiDi ext", "WiDi user", "Raw", "GrallocSource(Composer)", "GrallocSource(Gralloc)","MappingSurfaceForCI","Camera malloc For Extra Value"};
static const char* gRCModeString[4] ={"NO_RC", "CBR", "VBR", "VCM"};
+
+static uint32_t gOutPutFormat = 0;
+static const char* gOutPutFormatString[6] = {"OUTPUT_EVERYTHING","OUTPUT_CODEC_DATA","OUTPUT_FRAME_DATA","OUTPUT_ONE_NAL","OUTPUT_ONE_NAL_WITHOUT_STARTCODE","OUTPUT_LENGTH_PREFIXED"};
+
+static uint32_t gOutPutBufferSize = 1;
//for uploading src pictures, also for Camera malloc, WiDi clone, raw mode usrptr storage
static uint8_t* gUsrptr[gSrcFrames];
static uint8_t* gMallocPtr[gSrcFrames];
@@ -72,6 +89,16 @@
static sp<IGraphicBufferAlloc> gGraphicBufferAlloc;
static sp<GraphicBuffer> gGraphicBuffer[gSrcFrames];
+static int ev1[10];
+
+struct VideoConfigTypeIDRReq: VideoParamConfigSet {
+
+ VideoConfigTypeIDRReq() {
+ type = VideoConfigTypeIDRRequest;
+ size = sizeof(VideoConfigTypeIDRReq);
+ }
+};
+
extern "C" {
VAStatus vaLockSurface(VADisplay dpy,
VASurfaceID surface,
@@ -95,6 +122,8 @@
static gralloc_module_t const *gAllocMod; /* get by force hw_module_t */
static alloc_device_t *gAllocDev; /* get by gralloc_open */
+
+static int gCodeCoverageTestErrorCase = 0;
static void gfx_init()
{
int err = hw_get_module(GRALLOC_HARDWARE_MODULE_ID, &gModule);
@@ -217,6 +246,111 @@
ret = gVideoEncoder->setParameters(&gEncoderParams);
CHECK_ENCODE_STATUS("setParameters VideoParamsCommon");
+ gVideoEncoder->getParameters(&gVideoParamsAVC);
+ gVideoParamsAVC.crop.TopOffset = 1;
+ gVideoParamsAVC.VUIFlag = 1;
+ gVideoParamsAVC.SAR.SarWidth = 1;
+ gVideoEncoder->setParameters(&gVideoParamsAVC);
+
+ VideoParamsStoreMetaDataInBuffers tmpStoreMetaDataInBuffers;
+ gVideoEncoder->getParameters(&tmpStoreMetaDataInBuffers);
+ memset(&tmpStoreMetaDataInBuffers,0x00,sizeof(VideoParamsStoreMetaDataInBuffers));
+ gVideoEncoder->getParameters(&tmpStoreMetaDataInBuffers);
+ gVideoEncoder->setParameters(&tmpStoreMetaDataInBuffers);
+
+ VideoParamsUpstreamBuffer tmpVideoParamsUpstreamBuffer;
+ tmpVideoParamsUpstreamBuffer.bufCnt = 0;
+ gVideoEncoder->setParameters(&tmpVideoParamsUpstreamBuffer);
+
+ tmpVideoParamsUpstreamBuffer.bufCnt = gSrcFrames;
+ tmpVideoParamsUpstreamBuffer.bufAttrib = NULL;
+ gVideoEncoder->setParameters(&tmpVideoParamsUpstreamBuffer);
+/*
+ ExternalBufferAttrib attrib;
+ tmpVideoParamsUpstreamBuffer.bufCnt = gSrcFrames;
+ tmpVideoParamsUpstreamBuffer.bufAttrib = &attrib;
+ tmpVideoParamsUpstreamBuffer.bufferMode = BUFFER_LAST;
+ gVideoEncoder->setParameters(&tmpVideoParamsUpstreamBuffer);
+*/
+ VideoParamsUsrptrBuffer tmpVideoParamsUsrptrBuffer;
+ tmpVideoParamsUsrptrBuffer.width = 0;
+ gVideoEncoder->getParameters(&tmpVideoParamsUsrptrBuffer);
+
+ //---------------------add for libmix encode code coverage test
+ // VideoEncodeBase.cpp file setConfig && getConfig code coverage test
+ // only for VCM mode
+ if(gRC == RATE_CONTROL_VCM)
+ {
+ // for setConfig && getConfig default case
+ VideoConfigAIR configAIR1;
+ memset(&configAIR1,0x00,sizeof(VideoConfigAIR));
+ gVideoEncoder->setConfig(&configAIR1);
+ gVideoEncoder->getConfig(&configAIR1);
+
+ // VideoConfigTypeAIR setConfig and getConfig
+ VideoConfigAIR configAIR;
+ configAIR.airParams.airAuto = 0;
+ configAIR.airParams.airMBs = 0;
+ configAIR.airParams.airThreshold = 0;
+ gVideoEncoder->setConfig(&configAIR);
+ gVideoEncoder->getConfig(&configAIR);
+
+ // VideoConfigTypeBitRate setConfig and getConfig
+ VideoConfigBitRate configBitRate;
+ configBitRate.rcParams.bitRate = gBitrate;
+ configBitRate.rcParams.initQP = 15;
+ configBitRate.rcParams.minQP = 1;
+ configBitRate.rcParams.windowSize = 50;
+ configBitRate.rcParams.targetPercentage = 95;
+ gVideoEncoder->setConfig(&configBitRate);
+ gVideoEncoder->getConfig(&configBitRate);
+
+ // for VideoConfigTypeSliceNum derivedSetConfig && derivedGetConfig
+ VideoConfigSliceNum configSliceNum;
+ gVideoEncoder->getConfig(&configSliceNum);
+ gVideoEncoder->setConfig(&configSliceNum);
+
+ VideoConfigIntraRefreshType configIntraRefreshType;
+ configIntraRefreshType.refreshType = VIDEO_ENC_AIR;//VIDEO_ENC_AIR
+ gVideoEncoder->setConfig(&configIntraRefreshType);
+ gVideoEncoder->getConfig(&configIntraRefreshType);
+
+ // VideoConfigTypeFrameRate setConfig and getConfig
+ VideoConfigFrameRate configFrameRate;
+ configFrameRate.frameRate.frameRateDenom = 1;
+ configFrameRate.frameRate.frameRateNum = gFrameRate;
+ gVideoEncoder->setConfig(&configFrameRate);
+ gVideoEncoder->getConfig(&configFrameRate);
+
+ // VideoEncodeAVC.cpp file derivedSetConfig && derivedGetConfig code coverage test
+ // for VideoConfigTypeNALSize derivedSetConfig && derivedGetConfig
+ VideoConfigNALSize configNalSize;
+ configNalSize.maxSliceSize = 8*gWidth*gHeight*1.5;
+ gVideoEncoder->setConfig(&configNalSize);
+ gVideoEncoder->getConfig(&configNalSize);
+
+ VideoParamsHRD paramsHRD;
+ paramsHRD.bufferSize = (uint32_t)(gBitrate/gFrameRate) * 1024 * 8;
+ paramsHRD.initBufferFullness = (uint32_t)(gBitrate/gFrameRate);
+ gVideoEncoder->setParameters(¶msHRD);
+ gVideoEncoder->getParameters(¶msHRD);
+ }
+ else
+ {
+ // VideoConfigTypeCyclicFrameInterval setConfig and getConfig
+ VideoConfigCyclicFrameInterval configCyclicFrameInterval;
+ configCyclicFrameInterval.cyclicFrameInterval = 30;
+ gVideoEncoder->setConfig(&configCyclicFrameInterval);
+ gVideoEncoder->getConfig(&configCyclicFrameInterval);
+
+ // for VideoConfigTypeAVCIntraPeriod derivedSetConfig && derivedGetConfig
+ VideoConfigAVCIntraPeriod configAVCIntraPeriod;
+ gVideoEncoder->getConfig(&configAVCIntraPeriod);
+ gVideoEncoder->setConfig(&configAVCIntraPeriod);
+ VideoConfigTypeIDRReq tmpVideoConfigTypeIDRReq;
+ gVideoEncoder->setConfig(&tmpVideoConfigTypeIDRReq);
+ }
+
if (gMode != 4)
{
gStoreMetaDataInBuffers.isEnabled = true;
@@ -280,6 +414,34 @@
}
//malloc external memory, and not need to set into encoder before start()
+void MallocExternalMemoryWithExtraValues()
+{
+ uint32_t size = gWidth * gHeight * 3 /2;
+
+ ValueInfo* vinfo = new ValueInfo;
+ vinfo->mode = MEM_MODE_MALLOC;
+ vinfo->handle = 0;
+ vinfo->size = size;
+ vinfo->width = gWidth;
+ vinfo->height = gHeight;
+ vinfo->lumaStride = gStride;
+ vinfo->chromStride = gStride;
+ vinfo->format = STRING_TO_FOURCC("NV12");
+ vinfo->s3dformat = 0xFFFFFFFF;
+
+ for(int i = 0; i < gSrcFrames; i ++)
+ {
+ gUsrptr[i] = (uint8_t*)malloc(size);
+
+ gIMB[i] = new IntelMetadataBuffer(MetadataBufferTypeCameraSource, (int32_t)gUsrptr[i]);
+
+ gIMB[i]->SetValueInfo(vinfo);
+ }
+ delete vinfo;
+
+ gIMB[0]->SetExtraValues(ev1, 10);
+}
+//malloc external memory, and not need to set into encoder before start()
void MallocExternalMemory()
{
uint32_t size = gWidth * gHeight * 3 /2;
@@ -294,8 +456,8 @@
vinfo->chromStride = gStride;
vinfo->format = STRING_TO_FOURCC("NV12");
vinfo->s3dformat = 0xFFFFFFFF;
-
- for(int i = 0; i < gSrcFrames; i ++)
+
+ for(int i = 0; i < gSrcFrames; i ++)
{
gMallocPtr[i] = (uint8_t*)malloc(size + 4095);
gUsrptr[i] = (uint8_t*)((((int )gMallocPtr[i] + 4095) / 4096 ) * 4096);
@@ -459,6 +621,31 @@
}
}
+void CreateSurfaceMappingForCI()
+{
+ uint32_t size = gWidth * gHeight * 3 /2;
+
+ ValueInfo* vinfo = new ValueInfo;
+ vinfo->mode = MEM_MODE_CI;
+ vinfo->handle = 0;
+ vinfo->size = size;
+ vinfo->width = gWidth;
+ vinfo->height = gHeight;
+ vinfo->lumaStride = gStride;
+ vinfo->chromStride = gStride;
+ vinfo->format = STRING_TO_FOURCC("NV12");
+ vinfo->s3dformat = 0xFFFFFFFF;
+
+ for(int i = 0; i < gSrcFrames; i ++)
+ {
+ gUsrptr[i] = (uint8_t*)malloc(size);
+
+ gIMB[i] = new IntelMetadataBuffer(MetadataBufferTypeCameraSource, (int32_t)gUsrptr[i]);
+
+ gIMB[i]->SetValueInfo(vinfo);
+ }
+ delete vinfo;
+}
void CreateGfxhandle()
{
sp<ISurfaceComposer> composer(ComposerService::getComposerService());
@@ -530,7 +717,7 @@
{
char c;
- while ((c =getopt(argc, argv,"b:c:r:w:h:m:f:n:s:?") ) != EOF) {
+ while ((c =getopt(argc, argv,"b:c:r:w:h:m:f:n:s:o:e:z:?") ) != EOF) {
switch (c) {
case 'w':
gWidth = atoi(optarg);
@@ -566,6 +753,15 @@
case 'g':
gEncodeHeight = atoi(optarg);
break;
+ case 'o':
+ gOutPutFormat = atoi(optarg);
+ break;
+ case 'e':
+ gCodeCoverageTestErrorCase = atoi(optarg);
+ break;
+ case 'z':
+ gOutPutBufferSize = atoi(optarg);
+ break;
case '?':
default:
printf("\n./mix_encode -c <Codec> -b <Bit rate> -r <Rate control> -w <Width> -h <Height> -k <EncodeWidth> -g <EncodeHight> -n <Frame_num> -m <Mode> -s <Sync mode> -f <Output file>\n");
@@ -597,6 +793,7 @@
{
Encode_Status ret;
const char *codec;
+ VideoOutputFormat goutputformat = OUTPUT_EVERYTHING;
CheckArgs(argc, argv);
@@ -615,9 +812,20 @@
case 2:
codec = H263_MIME_TYPE;
break;
+//add for video encode libmix code coverage test--start
+ case 3:
+ codec = MPEG4_MIME_TYPE_SP;
+ break;
+ case 4:
+ codec = MEDIA_MIMETYPE_IMAGE_JPEG;
+ break;
+ case 5:
+ codec = NULL;
+ break;
default:
printf("Not support this type codec\n");
return 1;
+//add for video encode libmix code coverage test--end
}
switch(gRCMode)
@@ -638,15 +846,60 @@
printf("Not support this rate control mode\n");
return 1;
}
-
- printf("\nStart %s Encoding ....\n", codec);
- printf("Mode is %s, RC mode is %s, Src Width=%d, Height=%d, Encode Width=%d, Height=%d \n", gModeString[gMode], gRCModeString[gRCMode], gWidth, gHeight, gEncodeWidth, gEncodeHeight);
- printf("Bitrate=%dbps, EncodeFrames=%d, SyncMode=%d, out file is %s\n\n", gBitrate, gEncFrames, gSyncEncMode, gFile);
+
+ switch(gOutPutFormat)
+ {
+ case 0:
+ goutputformat = OUTPUT_EVERYTHING;
+ break;
+ case 1:
+ goutputformat = OUTPUT_CODEC_DATA;
+ break;
+ case 2:
+ goutputformat = OUTPUT_FRAME_DATA;
+ break;
+ case 3:
+ goutputformat = OUTPUT_ONE_NAL;
+ break;
+ case 4:
+ goutputformat = OUTPUT_ONE_NAL_WITHOUT_STARTCODE;
+ break;
+ case 5:
+ goutputformat = OUTPUT_LENGTH_PREFIXED;
+ break;
+ case 6:
+ goutputformat = OUTPUT_BUFFER_LAST;
+ break;
+ default:
+ printf("Not support this Out Put Format\n");
+ return 1;
+ }
+
+//add for video encode libmix code coverage test--start
+ if(codec != NULL)
+ printf("\nStart %s Encoding ....\n", codec);
+ else
+ printf("\nStart codec is null only for code coverage test ....\n");
+//add for video encode libmix code coverage test--end
+ printf("Mode is %s, RC mode is %s, Width=%d, Height=%d, Bitrate=%dbps, EncodeFrames=%d, SyncMode=%d, file is %s, outputnalformat is %s\n\n", gModeString[gMode], gRCModeString[gRCMode], gWidth, gHeight, gBitrate, gEncFrames, gSyncEncMode, gFile,gOutPutFormatString[gOutPutFormat]);
+
+//sleep(10);
for(int i=0; i<1; i++)
{
gVideoEncoder = createVideoEncoder(codec);
+ if(gVideoEncoder == NULL)
+ {
+ printf("Finishing code coverage test ....\n");
+ return 1;
+ }
+
+ // Adding for code coverage test
+ // VideoEncoderBase.cpp uncalled function
+ // VideoEncoderBase::flush()
+ gVideoEncoder->flush();
+
//set parameter
SetVideoEncoderParam();
@@ -675,6 +928,12 @@
case 6: //Gralloc
CreateGralloc();
break;
+ case 7: //SurfaceMappingForCI
+ CreateSurfaceMappingForCI();
+ break;
+ case 8: //Camera malloc with extra values
+ MallocExternalMemoryWithExtraValues();
+ break;
default:
break;
}
@@ -703,12 +962,17 @@
//output buffers
VideoEncOutputBuffer OutBuf;
uint32_t maxsize;
+ //for error hanlding
+ gVideoEncoder->getMaxOutSize(NULL);
gVideoEncoder->getMaxOutSize(&maxsize);
uint8_t out[maxsize];
- OutBuf.bufferSize = maxsize;
+ if(gOutPutBufferSize == 0)
+ OutBuf.bufferSize = 0;
+ else
+ OutBuf.bufferSize = maxsize;
OutBuf.dataSize = 0;
OutBuf.data = out;
- OutBuf.format = OUTPUT_EVERYTHING;
+ OutBuf.format = goutputformat;
printf("\n");
for(unsigned int i=0; i<gEncFrames; i++)
@@ -731,6 +995,7 @@
ret = gVideoEncoder->getOutput(&OutBuf);
CHECK_ENCODE_STATUS("getOutput");
+ CHECK_ENCODE_STATUS_RETURN("getOutput");
// printf("OutBuf.dataSize = %d .........\n", OutBuf.dataSize);
fwrite(OutBuf.data, 1, OutBuf.dataSize, file);
@@ -738,7 +1003,7 @@
fflush(stdout);
}
fclose(file);
-
+
VideoStatistics stat;
if (gVideoEncoder->getStatistics(&stat) == ENCODE_SUCCESS)
{
