void configureFromRead( const VideoFFmpegReader& reader )
{
setWidth ( reader.width() );
setHeight ( reader.height() );
setAspectRatio ( reader.aspectRatio() );
setFps ( reader.fps() );
setBitRate ( reader.bitRate() );
setFormat ( reader.formatName() );
setCodec ( reader.codecName() );
}
int midParseInt(int identifier,int fd, char *data, int len)
{
int recvlen;
int cmd = 0;
int actdata = 0;
//char logoname[15] = "logo.png";
int ret = 0;
int web_ret = SERVER_RET_OK;
int need_send = 0;
char senddata[1024] = {0};
int totallen = 0;
recvlen = recv(fd, data, len, 0);
int out = 0;
// if(recvlen < 0) {
// return -1;
// }
if(recvlen < 0 || len != sizeof(cmd) + sizeof(int)) {
web_ret = SERVER_RET_INVAID_PARM_LEN;
need_send = 1;
goto EXIT;
}
memcpy(&cmd, data, sizeof(int));
memcpy(&actdata, data + sizeof(int), len - sizeof(int));
PRINTF("cmd = 0x%04x\n", cmd);
switch(cmd) {
case MSG_GETINPUTTYPE:
PRINTF("cmd = 0x%04x is MSG_GETINPUTTYPE.\n", cmd);
ret = getinputType(actdata, &out);
need_send = 1;
break;
case MSG_SETINPUTTYPE:
PRINTF("cmd = 0x%04x is MSG_SETINPUTTYPE.\n", cmd);
ret = setInputType(actdata, &out);
need_send = 1;
break;
//case MSG_STOP_MULT:
// stopMultParse(fd, cmd, &actdata);
// break;
case MSG_GETCPULOAD:
PRINTF("cmd = 0x%04x is MSG_GETCPULOAD.\n", cmd);
ret = getcpuload(actdata, &out);
need_send = 1;
break;
case MSG_RESTORESET:
PRINTF("cmd = 0x%04x is MSG_RESTORESET.\n", cmd);
ret = restoresetparse(actdata, &out);
need_send = 1;
break;
case MSG_GET_CTRL_PROTO:
PRINTF("cmd = 0x%04x is MSG_GET_CTRL_PROTO.\n", cmd);
need_send = 1;
getCtrlProto(actdata, &out);
break;
case MSG_SET_CTRL_PROTO:
PRINTF("cmd = 0x%04x is MSG_SET_CTRL_PROTO.\n", cmd);
need_send = 1;
setCtrlProto(actdata, &out);
break;
/*
case MSG_SAVEPARAM:
saveParams(fd, cmd, &actdata);
break;
*/
#if 0
case MSG_GETDHCPFLAG:
PRINTF("cmd = 0x%04x is MSG_GETDHCPFLAG.\n", cmd);
need_send = 1;
PRINTF("MSG_GETDHCPFLAG actdata = %d\n", actdata);
webgetDHCPFlag(actdata, &out);
break;
case MSG_SETDHCPFLAG:
PRINTF("cmd = 0x%04x is MSG_SETDHCPFLAG.\n", cmd);
need_send = 1;
websetDHCPFlag(actdata, &out);
break;
#endif
case MSG_SETCOLORSPACE:
PRINTF("cmd = 0x%04x is MSG_SETCOLORSPACE.\n", cmd);
need_send = 1;
ret = setColorSpace(actdata, &out);
break;
case MSG_GETCOLORSPACE:
PRINTF("cmd = 0x%04x is MSG_GETCOLORSPACE.\n", cmd);
getColorSpace(&out);
need_send = 1;
break;
//case MSG_GETHDCPVAL:
// getHDCPValue(fd, cmd, &actdata);
// break;
case MSG_REBOOTSYS:
PRINTF("cmd = 0x%04x is MSG_REBOOTSYS.\n", cmd);
need_send = 1;
rebootSys(actdata, &out);
break;
case MSG_GETHDCPVALUE:
PRINTF("cmd = 0x%04x is MSG_GETHDCPVALUE.\n", cmd);
need_send = 1;
getHDCPValue(actdata, &out);
break;
case MSG_LOCK_RESOLUTION:
PRINTF("cmd = 0x%04x is MSG_LOCK_RESOLUTION.\n", cmd);
ret = DoLockResolution(actdata, &out);
need_send = 1;
break;
case MSG_GETOUTPUTRESOLUTION:
PRINTF("cmd = 0x%04x is MSG_GETOUTPUTRESOLUTION.\n", cmd);
ret = webgetOutputResolution(actdata, &out);
need_send = 1;
break;
case MSG_RESIZE_MODE:
PRINTF("cmd = 0x%04x is MSG_RESIZE_MODE.\n", cmd);
// setResizeMode(fd, cmd, &actdata);
ret = setResizeMode(actdata, &out);
need_send = 1;
break;
case MSG_GETRESIZEMODE:
PRINTF("cmd = 0x%04x is MSG_GETRESIZEMODE.\n", cmd);
//getResizeMode(fd, cmd, &actdata);
ret = getResizeMode(actdata, &out);
need_send = 1;
break;
case MSG_GETENCODELV:
PRINTF("cmd = 0x%04x is MSG_GETENCODELV.\n", cmd);
ret = getEncodelevel(actdata, &out);
need_send = 1;
break;
case MSG_SETENCODELV:
PRINTF("cmd = 0x%04x is MSG_SETENCODELV.\n", cmd);
ret = setEncodelevel(actdata, &out);
need_send = 1;
break;
case MSG_GETSCENE:
PRINTF("cmd = 0x%04x is MSG_GETSCENE.\n", cmd);
need_send = 1;
getSceneconfig(actdata, &out);
break;
case MSG_SETSCENE:
PRINTF("cmd = 0x%04x is MSG_SETSCENE.\n", cmd);
need_send = 1;
ret = setSceneconfig(actdata, &out);
break;
case MSG_GETFRAMERATE:
PRINTF("cmd = 0x%04x is MSG_GETFRAMERATE.\n", cmd);
need_send = 1;
getFrameRate(actdata, &out);
break;
case MSG_SETFRAMERATE:
PRINTF("cmd = 0x%04x is MSG_SETFRAMERATE.\n", cmd);
need_send = 1;
ret = setFrameRate(actdata, &out);
break;
case MSG_GETIFRAMEINTERVAL:
PRINTF("cmd = 0x%04x is MSG_GETIFRAMEINTERVAL.\n", cmd);
need_send = 1;
getIFrameInterval(actdata, &out);
break;
//case MSG_SETIFRAMEINTERVAL:
// PRINTF("cmd = 0x%04x is MSG_SETIFRAMEINTERVAL.\n", cmd);
// need_send = 1;
// ret = setIFrameInterval(actdata, &out);
// break;
case MSG_GETBITRATE:
PRINTF("cmd = 0x%04x is MSG_GETBITRATE.\n", cmd);
need_send = 1;
getBitRate(actdata, &out);
break;
case MSG_SETBITRATE:
PRINTF("cmd = 0x%04x is MSG_SETBITRATE.\n", cmd);
need_send = 1;
ret = setBitRate(actdata, &out);
break;
case MSG_SETMUTE:
PRINTF("cmd = 0x%04x is MSG_SETMUTE.\n", cmd);
need_send = 1;
ret = webSetMute(actdata, &out);
break;
case MSG_GETMUTE:
PRINTF("cmd = 0x%04x is MSG_GETMUTE.\n", cmd);
webGetMute(actdata, &out);
need_send = 1;
break;
//stream_ouput
case MSG_RTSP_GET_USED:
case MSG_RTSP_DEL_SERVER:
case MSG_MULT_GET_NUM:
case MSG_MULT_GET_TS_RATE:
case MSG_MULT_GET_RTP_RATE:
case MSG_MULT_GET_RTPTS_RATE:
app_web_stream_output_process_int(cmd, actdata, &out);
need_send = 1;
break;
//case MSG_GETSHOWTEXTLOGO:
// PRINTF("cmd = 0x%04x is MSG_GETSHOWTEXTLOGO.\n", cmd);
// webgetShowLogoTextFlag(actdata, &out);
// need_send = 1;
// break;
// case MSG_SETSHOWTEXTLOGO:
// PRINTF("cmd = 0x%04x is MSG_SETSHOWTEXTLOGO.\n", cmd);
// ret = websetShowLogoTextFlag(actdata, &out);
// need_send = 1;
// break;
// case MSG_GET_SHOWTEXT_FLAG:
// out = app_get_textshow_flag();
// need_send = 1;
// break;
// case MSG_SET_SHOWTEXT_FLAG:
// out = app_set_textshow_flag(actdata);
// need_send = 1;
// break;
// case MSG_GET_SHOWLOGO_FLAG:
// out = app_get_logoshow_flag();
// need_send = 1;
// break;
// case MSG_SET_SHOWLOGO_FLAG:
// out = app_set_logoshow_flag(actdata);
// need_send = 1;
// break;
default:
PRINTF("unkonwn cmd = %04x\n", cmd);
need_send = 1;
web_ret = SERVER_RET_UNKOWN_CMD;
break;
// case
}
if(ret < 0) {
web_ret = SERVER_RET_INVAID_PARM_VALUE;
}
EXIT:
if(need_send == 1) {
totallen = MSGINFOHEAD + sizeof(cmd) + sizeof(web_ret) + sizeof(out);
msgPacket(identifier,senddata, INT_TYPE, totallen, cmd, web_ret);
memcpy(senddata + (totallen - sizeof(out)), &out, sizeof(out));
PRINTF("the cmd =%04x,the value=%d,the ret=%04x\n", cmd, out, web_ret);
send(fd, senddata, totallen, 0);
}
return 0;
}
OMX_ERRORTYPE SoftAVC::initEncoder() {
IV_STATUS_T status;
WORD32 level;
uint32_t displaySizeY;
CHECK(!mStarted);
OMX_ERRORTYPE errType = OMX_ErrorNone;
displaySizeY = mWidth * mHeight;
if (displaySizeY > (1920 * 1088)) {
level = 50;
} else if (displaySizeY > (1280 * 720)) {
level = 40;
} else if (displaySizeY > (720 * 576)) {
level = 31;
} else if (displaySizeY > (624 * 320)) {
level = 30;
} else if (displaySizeY > (352 * 288)) {
level = 21;
} else {
level = 20;
}
mAVCEncLevel = MAX(level, mAVCEncLevel);
mStride = mWidth;
if (mInputDataIsMeta) {
for (size_t i = 0; i < MAX_CONVERSION_BUFFERS; i++) {
if (mConversionBuffers[i] != NULL) {
free(mConversionBuffers[i]);
mConversionBuffers[i] = 0;
}
if (((uint64_t)mStride * mHeight) > ((uint64_t)INT32_MAX / 3)) {
ALOGE("Buffer size is too big.");
return OMX_ErrorUndefined;
}
mConversionBuffers[i] = (uint8_t *)malloc(mStride * mHeight * 3 / 2);
if (mConversionBuffers[i] == NULL) {
ALOGE("Allocating conversion buffer failed.");
return OMX_ErrorUndefined;
}
mConversionBuffersFree[i] = 1;
}
}
switch (mColorFormat) {
case OMX_COLOR_FormatYUV420SemiPlanar:
mIvVideoColorFormat = IV_YUV_420SP_UV;
ALOGV("colorFormat YUV_420SP");
break;
default:
case OMX_COLOR_FormatYUV420Planar:
mIvVideoColorFormat = IV_YUV_420P;
ALOGV("colorFormat YUV_420P");
break;
}
ALOGD("Params width %d height %d level %d colorFormat %d", mWidth,
mHeight, mAVCEncLevel, mIvVideoColorFormat);
/* Getting Number of MemRecords */
{
iv_num_mem_rec_ip_t s_num_mem_rec_ip;
iv_num_mem_rec_op_t s_num_mem_rec_op;
s_num_mem_rec_ip.u4_size = sizeof(iv_num_mem_rec_ip_t);
s_num_mem_rec_op.u4_size = sizeof(iv_num_mem_rec_op_t);
s_num_mem_rec_ip.e_cmd = IV_CMD_GET_NUM_MEM_REC;
status = ive_api_function(0, &s_num_mem_rec_ip, &s_num_mem_rec_op);
if (status != IV_SUCCESS) {
ALOGE("Get number of memory records failed = 0x%x\n",
s_num_mem_rec_op.u4_error_code);
return OMX_ErrorUndefined;
}
mNumMemRecords = s_num_mem_rec_op.u4_num_mem_rec;
}
/* Allocate array to hold memory records */
if (mNumMemRecords > SIZE_MAX / sizeof(iv_mem_rec_t)) {
ALOGE("requested memory size is too big.");
return OMX_ErrorUndefined;
}
mMemRecords = (iv_mem_rec_t *)malloc(mNumMemRecords * sizeof(iv_mem_rec_t));
if (NULL == mMemRecords) {
ALOGE("Unable to allocate memory for hold memory records: Size %zu",
mNumMemRecords * sizeof(iv_mem_rec_t));
mSignalledError = true;
notify(OMX_EventError, OMX_ErrorUndefined, 0, 0);
return OMX_ErrorUndefined;
}
{
iv_mem_rec_t *ps_mem_rec;
ps_mem_rec = mMemRecords;
for (size_t i = 0; i < mNumMemRecords; i++) {
ps_mem_rec->u4_size = sizeof(iv_mem_rec_t);
ps_mem_rec->pv_base = NULL;
ps_mem_rec->u4_mem_size = 0;
ps_mem_rec->u4_mem_alignment = 0;
ps_mem_rec->e_mem_type = IV_NA_MEM_TYPE;
ps_mem_rec++;
}
}
/* Getting MemRecords Attributes */
{
iv_fill_mem_rec_ip_t s_fill_mem_rec_ip;
iv_fill_mem_rec_op_t s_fill_mem_rec_op;
s_fill_mem_rec_ip.u4_size = sizeof(iv_fill_mem_rec_ip_t);
s_fill_mem_rec_op.u4_size = sizeof(iv_fill_mem_rec_op_t);
s_fill_mem_rec_ip.e_cmd = IV_CMD_FILL_NUM_MEM_REC;
s_fill_mem_rec_ip.ps_mem_rec = mMemRecords;
s_fill_mem_rec_ip.u4_num_mem_rec = mNumMemRecords;
s_fill_mem_rec_ip.u4_max_wd = mWidth;
s_fill_mem_rec_ip.u4_max_ht = mHeight;
s_fill_mem_rec_ip.u4_max_level = mAVCEncLevel;
s_fill_mem_rec_ip.e_color_format = DEFAULT_INP_COLOR_FORMAT;
s_fill_mem_rec_ip.u4_max_ref_cnt = DEFAULT_MAX_REF_FRM;
s_fill_mem_rec_ip.u4_max_reorder_cnt = DEFAULT_MAX_REORDER_FRM;
s_fill_mem_rec_ip.u4_max_srch_rng_x = DEFAULT_MAX_SRCH_RANGE_X;
s_fill_mem_rec_ip.u4_max_srch_rng_y = DEFAULT_MAX_SRCH_RANGE_Y;
status = ive_api_function(0, &s_fill_mem_rec_ip, &s_fill_mem_rec_op);
if (status != IV_SUCCESS) {
ALOGE("Fill memory records failed = 0x%x\n",
s_fill_mem_rec_op.u4_error_code);
mSignalledError = true;
notify(OMX_EventError, OMX_ErrorUndefined, 0, 0);
return OMX_ErrorUndefined;
}
}
/* Allocating Memory for Mem Records */
{
WORD32 total_size;
iv_mem_rec_t *ps_mem_rec;
total_size = 0;
ps_mem_rec = mMemRecords;
for (size_t i = 0; i < mNumMemRecords; i++) {
ps_mem_rec->pv_base = ive_aligned_malloc(
ps_mem_rec->u4_mem_alignment, ps_mem_rec->u4_mem_size);
if (ps_mem_rec->pv_base == NULL) {
ALOGE("Allocation failure for mem record id %zu size %u\n", i,
ps_mem_rec->u4_mem_size);
mSignalledError = true;
notify(OMX_EventError, OMX_ErrorUndefined, 0, 0);
return OMX_ErrorUndefined;
}
total_size += ps_mem_rec->u4_mem_size;
ps_mem_rec++;
}
}
/* Codec Instance Creation */
{
ive_init_ip_t s_init_ip;
ive_init_op_t s_init_op;
mCodecCtx = (iv_obj_t *)mMemRecords[0].pv_base;
mCodecCtx->u4_size = sizeof(iv_obj_t);
mCodecCtx->pv_fxns = (void *)ive_api_function;
s_init_ip.u4_size = sizeof(ive_init_ip_t);
s_init_op.u4_size = sizeof(ive_init_op_t);
s_init_ip.e_cmd = IV_CMD_INIT;
s_init_ip.u4_num_mem_rec = mNumMemRecords;
s_init_ip.ps_mem_rec = mMemRecords;
s_init_ip.u4_max_wd = mWidth;
s_init_ip.u4_max_ht = mHeight;
s_init_ip.u4_max_ref_cnt = DEFAULT_MAX_REF_FRM;
s_init_ip.u4_max_reorder_cnt = DEFAULT_MAX_REORDER_FRM;
s_init_ip.u4_max_level = mAVCEncLevel;
s_init_ip.e_inp_color_fmt = mIvVideoColorFormat;
if (mReconEnable || mPSNREnable) {
s_init_ip.u4_enable_recon = 1;
} else {
s_init_ip.u4_enable_recon = 0;
}
s_init_ip.e_recon_color_fmt = DEFAULT_RECON_COLOR_FORMAT;
s_init_ip.e_rc_mode = DEFAULT_RC_MODE;
s_init_ip.u4_max_framerate = DEFAULT_MAX_FRAMERATE;
s_init_ip.u4_max_bitrate = DEFAULT_MAX_BITRATE;
s_init_ip.u4_num_bframes = mBframes;
s_init_ip.e_content_type = IV_PROGRESSIVE;
s_init_ip.u4_max_srch_rng_x = DEFAULT_MAX_SRCH_RANGE_X;
s_init_ip.u4_max_srch_rng_y = DEFAULT_MAX_SRCH_RANGE_Y;
s_init_ip.e_slice_mode = mSliceMode;
s_init_ip.u4_slice_param = mSliceParam;
s_init_ip.e_arch = mArch;
s_init_ip.e_soc = DEFAULT_SOC;
status = ive_api_function(mCodecCtx, &s_init_ip, &s_init_op);
if (status != IV_SUCCESS) {
ALOGE("Init memory records failed = 0x%x\n",
s_init_op.u4_error_code);
mSignalledError = true;
notify(OMX_EventError, OMX_ErrorUndefined, 0 /* arg2 */, NULL /* data */);
return OMX_ErrorUndefined;
}
}
/* Get Codec Version */
logVersion();
/* set processor details */
setNumCores();
/* Video control Set Frame dimensions */
setDimensions();
/* Video control Set Frame rates */
setFrameRate();
/* Video control Set IPE Params */
setIpeParams();
/* Video control Set Bitrate */
setBitRate();
/* Video control Set QP */
setQp();
/* Video control Set AIR params */
setAirParams();
/* Video control Set VBV params */
setVbvParams();
/* Video control Set Motion estimation params */
setMeParams();
/* Video control Set GOP params */
setGopParams();
/* Video control Set Deblock params */
setDeblockParams();
/* Video control Set Profile params */
setProfileParams();
/* Video control Set in Encode header mode */
setEncMode(IVE_ENC_MODE_HEADER);
ALOGV("init_codec successfull");
mSpsPpsHeaderReceived = false;
mStarted = true;
return OMX_ErrorNone;
}
/*===========================================================================*
*
* ReadParamFile
*
* read the parameter file
* function is ENCODE_FRAMES, COMBINE_GOPS, or COMBINE_FRAMES, and
* will slightly modify the procedure's behavior as to what it
* is looking for in the parameter file
*
* RETURNS: TRUE if the parameter file was read correctly; FALSE if not
*
* SIDE EFFECTS: sets parameters accordingly, as well as machine info for
* parallel execution and input file names
*
*===========================================================================*/
boolean
ReadParamFile(char *fileName,
int function)
{
numInputFileEntries = 0; // for gmsh
FILE *fpointer;
char input[256];
char *charPtr;
boolean yuvUsed = FALSE;
/*
static const char *optionText[LAST_OPTION+1] = { "GOP_SIZE", "PATTERN", "PIXEL", "PQSCALE",
"OUTPUT", "RANGE", "PSEARCH_ALG", "IQSCALE", "INPUT_DIR",
"INPUT_CONVERT", "INPUT", "BQSCALE", "BASE_FILE_FORMAT",
"SLICES_PER_FRAME", "BSEARCH_ALG", "REFERENCE_FRAME"};
*/
register int index;
register int row, col;
if ( (fpointer = fopen(fileName, "r")) == NULL ) {
fprintf(stderr, "Error: Cannot open parameter file: %s\n", fileName);
return FALSE;
}
/* should set defaults */
numInputFiles = 0;
numMachines = 0;
sprintf(currentPath, ".");
sprintf(currentGOPPath, ".");
sprintf(currentFramePath, ".");
#ifndef HPUX
SetRemoteShell((char*)"rsh");
#else
SetRemoteShell("remsh");
#endif
switch(function) {
case ENCODE_FRAMES:
for ( index = FIRST_OPTION; index <= LAST_OPTION; index++ ) {
optionSeen[index] = FALSE;
}
optionSeen[OPTION_IO_CONVERT] = FALSE;
optionSeen[OPTION_SLAVE_CONVERT] = FALSE;
break;
case COMBINE_GOPS:
for ( index = FIRST_OPTION; index <= LAST_OPTION; index++ ) {
optionSeen[index] = TRUE;
}
optionSeen[OPTION_OUTPUT] = FALSE;
break;
case COMBINE_FRAMES:
for ( index = FIRST_OPTION; index <= LAST_OPTION; index++ ) {
optionSeen[index] = TRUE;
}
optionSeen[OPTION_GOP] = FALSE;
optionSeen[OPTION_OUTPUT] = FALSE;
break;
}
for( index=LAST_OPTION+1; index<= NUM_OPTIONS; index++ ) {
optionSeen[index]=FALSE;
}
while ( fgets(input, 256, fpointer) != NULL ) {
/* skip comments */
if ( input[0] == '#' ) {
continue;
}
{
int len = strlen(input);
if (input[len-1] == '\n') {
len--;
input[len] = '\0'; /* get rid of newline */
/* Junk whitespace */
while ((len >= 0) && ((input[len-1] == ' ') || (input[len-1] == '\t'))) {
input[--len] = '\0';
}
}
}
if (strlen(SkipSpacesTabs(input)) == 0) continue;
switch(input[0]) {
case 'A':
if ( strncmp(input, "ASPECT_RATIO", 12) == 0 ) {
charPtr = SkipSpacesTabs(&input[12]);
aspectRatio = GetAspectRatio(charPtr);
optionSeen[OPTION_ASPECT_RATIO] = TRUE;
}
break;
case 'B':
if ( strncmp(input, "BQSCALE", 7) == 0 ) {
charPtr = SkipSpacesTabs(&input[7]);
SetBQScale(atoi(charPtr));
optionSeen[OPTION_BQSCALE] = TRUE;
} else if ( strncmp(input, "BASE_FILE_FORMAT", 16) == 0 ) {
charPtr = SkipSpacesTabs(&input[16]);
SetFileFormat(charPtr);
if ( (strncmp(charPtr,"YUV",3) == 0) ||
(strcmp(charPtr,"Y") == 0) ) {
yuvUsed = TRUE;
}
optionSeen[OPTION_BASE_FORMAT] = TRUE;
} else if ( strncmp(input, "BSEARCH_ALG", 11) == 0 ) {
charPtr = SkipSpacesTabs(&input[11]);
SetBSearchAlg(charPtr);
optionSeen[OPTION_BSEARCH_ALG] = TRUE;
} else if ( strncmp(input, "BIT_RATE", 8) == 0 ) {
charPtr = SkipSpacesTabs(&input[8]);
setBitRate(charPtr);
optionSeen[OPTION_BIT_RATE] = TRUE;
} else if ( strncmp(input, "BUFFER_SIZE", 11) == 0 ) {
charPtr = SkipSpacesTabs(&input[11]);
setBufferSize(charPtr);
optionSeen[OPTION_BUFFER_SIZE] = TRUE;
}
break;
case 'C':
if ( strncmp(input, "CDL_FILE", 8) == 0 ) {
charPtr = SkipSpacesTabs(&input[8]);
strcpy(specificsFile, charPtr);
specificsOn=TRUE;
optionSeen[OPTION_SPECIFICS] = TRUE;
} else if ( strncmp(input, "CDL_DEFINES", 11) == 0 ) {
charPtr = SkipSpacesTabs(&input[11]);
strcpy(specificsDefines, charPtr);
optionSeen[OPTION_DEFS_SPECIFICS] = TRUE;
}
break;
case 'F':
if ( strncmp(input, "FRAME_INPUT_DIR", 15) == 0 ) {
charPtr = SkipSpacesTabs(&input[15]);
if ( strncmp(charPtr, "stdin", 5) == 0 ||
strncmp(charPtr, "STDIN", 5) == 0 ) {
stdinUsed = TRUE;
numInputFiles = MAXINT;
numInputFileEntries = 1;
}
strcpy(currentFramePath, charPtr);
} else if ( strncmp(input, "FRAME_INPUT", 11) == 0 ) {
if ( function == COMBINE_FRAMES ) {
ReadInputFileNames(fpointer, "FRAME_END_INPUT");
}
} else if ( strncmp(input, "FORCE_I_ALIGN", 13) == 0 ) {
forceIalign = TRUE;
} else if ( strncmp(input, "FORCE_ENCODE_LAST_FRAME", 23) == 0 ) {
forceEncodeLast = TRUE;
} else if ( strncmp(input, "FRAME_RATE", 10) == 0 ) {
charPtr = SkipSpacesTabs(&input[10]);
frameRate = GetFrameRate(charPtr);
frameRateRounded = (int) VidRateNum[frameRate];
if ( (frameRate % 3) == 1) {
frameRateInteger = FALSE;
}
optionSeen[OPTION_FRAME_RATE] = TRUE;
}
break;
case 'G':
if ( strncmp(input, "GOP_SIZE", 8) == 0 ) {
charPtr = SkipSpacesTabs(&input[8]);
SetGOPSize(atoi(charPtr));
optionSeen[OPTION_GOP] = TRUE;
} else if ( strncmp(input, "GOP_INPUT_DIR", 13) == 0 ) {
charPtr = SkipSpacesTabs(&input[13]);
if ( strncmp(charPtr, "stdin", 5) == 0 ||
strncmp(charPtr, "STDIN", 5) == 0 ) {
stdinUsed = TRUE;
numInputFiles = MAXINT;
numInputFileEntries = 1;
}
strcpy(currentGOPPath, charPtr);
} else if ( strncmp(input, "GOP_INPUT", 9) == 0 ) {
if ( function == COMBINE_GOPS ) {
ReadInputFileNames(fpointer, "GOP_END_INPUT");
}
} else if ( strncmp(input, "GAMMA", 5) == 0) {
charPtr = SkipSpacesTabs(&input[5]);
GammaCorrection = TRUE;
sscanf(charPtr,"%f",&GammaValue);
optionSeen[OPTION_GAMMA] = TRUE;
}
break;
case 'I':
if ( strncmp(input, "IQSCALE", 7) == 0 ) {
charPtr = SkipSpacesTabs(&input[7]);
SetIQScale(atoi(charPtr));
optionSeen[OPTION_IQSCALE] = TRUE;
} else if ( strncmp(input, "INPUT_DIR", 9) == 0 ) {
charPtr = SkipSpacesTabs(&input[9]);
if ( strncmp(charPtr, "stdin", 5) == 0 ||
strncmp(charPtr, "STDIN", 5) == 0 ) {
stdinUsed = TRUE;
numInputFiles = MAXINT;
numInputFileEntries = 1;
}
strcpy(currentPath, charPtr);
optionSeen[OPTION_INPUT_DIR] = TRUE;
} else if ( strncmp(input, "INPUT_CONVERT", 13) == 0 ) {
charPtr = SkipSpacesTabs(&input[13]);
strcpy(inputConversion, charPtr);
optionSeen[OPTION_INPUT_CONVERT] = TRUE;
} else if ( strcmp(input, "INPUT") == 0 ) { /* yes, strcmp */
if ( function == ENCODE_FRAMES ) {
ReadInputFileNames(fpointer, "END_INPUT");
optionSeen[OPTION_INPUT] = TRUE;
}
} else if ( strncmp(input, "IO_SERVER_CONVERT", 17) == 0 ) {
charPtr = SkipSpacesTabs(&input[17]);
strcpy(ioConversion, charPtr);
optionSeen[OPTION_IO_CONVERT] = TRUE;
} else if ( strncmp(input, "IQTABLE", 7) == 0 ) {
for ( row = 0; row < 8; row ++ ) {
if(!fgets(input, 256, fpointer)) return FALSE;
charPtr = input;
if (8!=sscanf(charPtr,"%d %d %d %d %d %d %d %d",
&qtable[row*8+0], &qtable[row*8+1],
&qtable[row*8+2], &qtable[row*8+3],
&qtable[row*8+4], &qtable[row*8+5],
&qtable[row*8+6], &qtable[row*8+7])) {
throw "Line of IQTABLE doesn't have 8 elements!";
}
for ( col = 0; col < 8; col ++ ) {
if ((qtable[row*8+col]<1) || (qtable[row*8+col]>255)) {
fprintf(stderr,
"Warning: IQTable Element %1d,%1d (%d) corrected to 1-255.\n",
row+1, col+1, qtable[row*8+col]);
qtable[row*8+col] = (qtable[row*8+col]<1)?1:255;
}}
}
if ( qtable[0] != 8 ) {
fprintf(stderr, "Warning: IQTable Element 1,1 reset to 8, since it must be 8.\n");
qtable[0] = 8;
}
customQtable = qtable;
optionSeen[OPTION_IQTABLE] = TRUE;
} else if ( strncmp(input, "INPUT", 5) == 0 ) { /* handle spaces after input */
//log(10.0);
charPtr = SkipSpacesTabs(&input[5]);
if ( function == ENCODE_FRAMES && *charPtr==0) {
ReadInputFileNames(fpointer, "END_INPUT");
optionSeen[OPTION_INPUT] = TRUE;
}
}
break;
case 'N':
if ( strncmp(input, "NIQTABLE", 8) == 0 ) {
for ( row = 0; row < 8; row ++ ) {
if(!fgets(input, 256, fpointer)) return FALSE;
charPtr = input;
if (8!=sscanf(charPtr,"%d %d %d %d %d %d %d %d",
&niqtable[row*8+0], &niqtable[row*8+1],
&niqtable[row*8+2], &niqtable[row*8+3],
&niqtable[row*8+4], &niqtable[row*8+5],
&niqtable[row*8+6], &niqtable[row*8+7])) {
throw "Line of NIQTABLE doesn't have 8 elements!";
}
for ( col = 0; col < 8; col++ ) {
if ((niqtable[row*8+col]<1) || (niqtable[row*8+col]>255)) {
fprintf(stderr,
"Warning: NIQTable Element %1d,%1d (%d) corrected to 1-255.\n",
row+1, col+1, niqtable[row*8+col]);
niqtable[row*8+col]=(niqtable[row*8+col]<1)?1:255;
}}
}
customNIQtable = niqtable;
optionSeen[OPTION_NIQTABLE] = TRUE;
}
break;
case 'O':
if ( strncmp(input, "OUTPUT", 6) == 0 ) {
charPtr = SkipSpacesTabs(&input[6]);
if ( whichGOP == -1 ) {
strcpy(outputFileName, charPtr);
} else {
sprintf(outputFileName, "%s.gop.%d",
charPtr, whichGOP);
}
optionSeen[OPTION_OUTPUT] = TRUE;
}
break;
case 'P':
if ( strncmp(input, "PATTERN", 7) == 0 ) {
charPtr = SkipSpacesTabs(&input[7]);
SetFramePattern(charPtr);
optionSeen[OPTION_PATTERN] = TRUE;
} else if ( strncmp(input, "PIXEL", 5) == 0 ) {
charPtr = SkipSpacesTabs(&input[5]);
SetPixelSearch(charPtr);
optionSeen[OPTION_PIXEL] = TRUE;
} else if ( strncmp(input, "PQSCALE", 7) == 0 ) {
charPtr = SkipSpacesTabs(&input[7]);
SetPQScale(atoi(charPtr));
optionSeen[OPTION_PQSCALE] = TRUE;
} else if ( strncmp(input, "PSEARCH_ALG", 11) == 0 ) {
charPtr = SkipSpacesTabs(&input[11]);
SetPSearchAlg(charPtr);
optionSeen[OPTION_PSEARCH_ALG] = TRUE;
} else if ( strncmp(input, "PARALLEL_TEST_FRAMES", 20) == 0 ) {
SetParallelPerfect(FALSE);
charPtr = SkipSpacesTabs(&input[20]);
parallelTestFrames = atoi(charPtr);
} else if ( strncmp(input, "PARALLEL_TIME_CHUNKS", 20) == 0 ) {
SetParallelPerfect(FALSE);
charPtr = SkipSpacesTabs(&input[20]);
parallelTimeChunks = atoi(charPtr);
} else if ( strncmp(input, "PARALLEL_CHUNK_TAPER", 20) == 0 ) {
SetParallelPerfect(FALSE);
parallelTimeChunks = -1;
} else if ( strncmp(input, "PARALLEL_PERFECT", 16) == 0 ) {
SetParallelPerfect(TRUE);
} else if ( strncmp(input, "PARALLEL", 8) == 0 ) {
ReadMachineNames(fpointer);
optionSeen[OPTION_PARALLEL] = TRUE;
}
break;
case 'R':
if ( strncmp(input, "RANGE", 5) == 0 ) {
int num_ranges=0,a,b;
charPtr = SkipSpacesTabs(&input[5]);
optionSeen[OPTION_RANGE] = TRUE;
num_ranges=sscanf(charPtr,"%d %d",&a,&b);
if (num_ranges==2) {
SetSearchRange(a,b);
} else if (sscanf(charPtr,"%d [%d]",&a,&b)==2) {
SetSearchRange(a,b);
} else SetSearchRange(a,a);
} else if ( strncmp(input, "REFERENCE_FRAME", 15) == 0 ) {
charPtr = SkipSpacesTabs(&input[15]);
SetReferenceFrameType(charPtr);
optionSeen[OPTION_REF_FRAME] = TRUE;
} else if ( strncmp(input, "RSH", 3) == 0 ) {
charPtr = SkipSpacesTabs(&input[3]);
SetRemoteShell(charPtr);
} else if ( strncmp(input, "RESIZE", 6) == 0 ) {
charPtr = SkipSpacesTabs(&input[6]);
sscanf(charPtr, "%dx%d", &outputWidth, &outputHeight);
outputWidth &= ~(DCTSIZE * 2 - 1);
outputHeight &= ~(DCTSIZE * 2 - 1);
optionSeen[OPTION_RESIZE] = TRUE;
}
break;
case 'S':
if ( strncmp(input, "SLICES_PER_FRAME", 16) == 0 ) {
charPtr = SkipSpacesTabs(&input[16]);
SetSlicesPerFrame(atoi(charPtr));
optionSeen[OPTION_SPF] = TRUE;
} else if ( strncmp(input, "SLAVE_CONVERT", 13) == 0 ) {
charPtr = SkipSpacesTabs(&input[13]);
strcpy(slaveConversion, charPtr);
optionSeen[OPTION_SLAVE_CONVERT] = TRUE;
} else if ( strncmp(input, "SPECIFICS_FILE", 14) == 0 ) {
charPtr = SkipSpacesTabs(&input[14]);
strcpy(specificsFile, charPtr);
specificsOn=TRUE;
optionSeen[OPTION_SPECIFICS] = TRUE;
} else if ( strncmp(input, "SPECIFICS_DEFINES", 16) == 0 ) {
charPtr = SkipSpacesTabs(&input[17]);
strcpy(specificsDefines, charPtr);
optionSeen[OPTION_DEFS_SPECIFICS] = TRUE;
} else if (strncmp(input, "SEQUENCE_SIZE", 13) == 0) {
charPtr = SkipSpacesTabs(&input[13]);
mult_seq_headers = atoi(charPtr);
} else if (strncmp(input, "SIZE", 4) == 0 ) {
charPtr = SkipSpacesTabs(&input[4]);
sscanf(charPtr, "%dx%d", &yuvWidth, &yuvHeight);
realWidth = yuvWidth;
realHeight = yuvHeight;
Fsize_Validate(&yuvWidth, &yuvHeight);
optionSeen[OPTION_YUV_SIZE] = TRUE;
}
break;
case 'T':
if ( strncmp(input, "TUNE", 4) == 0) {
tuneingOn = TRUE;
charPtr = SkipSpacesTabs(&input[4]);
ParseTuneParam(charPtr);
}
break;
case 'U':
if ( strncmp(input, "USER_DATA", 9) == 0 ) {
charPtr = SkipSpacesTabs(&input[9]);
strcpy((char*)userDataFileName, charPtr);
optionSeen[OPTION_USER_DATA] = TRUE;
}
break;
case 'Y':
if (strncmp(input, "YUV_SIZE", 8) == 0 ) {
charPtr = SkipSpacesTabs(&input[8]);
sscanf(charPtr, "%dx%d", &yuvWidth, &yuvHeight);
realWidth = yuvWidth;
realHeight = yuvHeight;
Fsize_Validate(&yuvWidth, &yuvHeight);
optionSeen[OPTION_YUV_SIZE] = TRUE;
}
else if (strncmp(input, "Y_SIZE", 6) == 0 ) {
charPtr = SkipSpacesTabs(&input[6]);
sscanf(charPtr, "%dx%d", &yuvWidth, &yuvHeight);
realWidth = yuvWidth;
realHeight = yuvHeight;
Fsize_Validate(&yuvWidth, &yuvHeight);
optionSeen[OPTION_YUV_SIZE] = TRUE;
}
else if ( strncmp(input, "YUV_FORMAT", 10) == 0 ) {
charPtr = SkipSpacesTabs(&input[10]);
strcpy(yuvConversion, charPtr);
optionSeen[OPTION_YUV_FORMAT] = TRUE;
}
break;
}
}
fclose(fpointer);
for ( index = FIRST_OPTION; index <= LAST_OPTION; index++ ) {
if ( ! optionSeen[index] ) {
/* INPUT unnecessary when stdin is used */
if ((index == OPTION_INPUT) && stdinUsed) {
continue;
}
throw "Missing option";
}
}
/* error checking */
if ( yuvUsed ) {
if (! optionSeen[OPTION_YUV_SIZE]) {
throw "YUV format used but YUV_SIZE not given";
}
if (! optionSeen[OPTION_YUV_FORMAT]) {
strcpy (yuvConversion, "EYUV");
fprintf(stderr, "WARNING: YUV format not specified; defaulting to Berkeley YUV (EYUV)\n\n");
}
}
if ( stdinUsed && optionSeen[OPTION_PARALLEL] ) {
throw "stdin reading for parallel execution not enabled yet";
}
if ( optionSeen[OPTION_PARALLEL] && !optionSeen[OPTION_YUV_SIZE]) {
throw "Specify SIZE WxH for parallel encoding";
}
if ( optionSeen[OPTION_IO_CONVERT] != optionSeen[OPTION_SLAVE_CONVERT] ) {
throw "must have either both IO_SERVER_CONVERT and SLAVE_CONVERT or neither";
}
if ( optionSeen[OPTION_DEFS_SPECIFICS] && !optionSeen[OPTION_SPECIFICS]) {
throw "does not make sense to define Specifics file options, but no specifics file";
}
SetIOConvert(optionSeen[OPTION_IO_CONVERT]);
SetResize(optionSeen[OPTION_RESIZE]);
if ( function == ENCODE_FRAMES ) {
SetFCode();
if ( psearchAlg == PSEARCH_TWOLEVEL )
SetPixelSearch((char*)"HALF");
}
return TRUE;
}
