1353 lines
49 KiB
C
1353 lines
49 KiB
C
/*
|
|
* @DEC_COPYRIGHT@
|
|
*/
|
|
/*
|
|
* HISTORY
|
|
* $Log: slib_param.c,v $
|
|
* Revision 1.1.6.25 1996/12/13 18:19:09 Hans_Graves
|
|
* Adjust file size in NEED_ACCURACY, if end of file is bad.
|
|
* [1996/12/13 18:13:11 Hans_Graves]
|
|
*
|
|
* Revision 1.1.6.24 1996/12/12 20:54:47 Hans_Graves
|
|
* Fixed NT compile warning with use of ftime.
|
|
* [1996/12/12 20:51:38 Hans_Graves]
|
|
*
|
|
* Revision 1.1.6.23 1996/12/05 20:10:18 Hans_Graves
|
|
* Change max choosen MPEG audio bitrate to 192kbits
|
|
* [1996/12/05 20:09:25 Hans_Graves]
|
|
*
|
|
* Revision 1.1.6.22 1996/12/04 22:34:34 Hans_Graves
|
|
* Make seeking in NEEDACCURACY quicker when seeks fail.
|
|
* [1996/12/04 22:20:18 Hans_Graves]
|
|
*
|
|
* Revision 1.1.6.21 1996/12/03 23:15:18 Hans_Graves
|
|
* MME-1498: Made seeks with PERCENT100 more accurate
|
|
* [1996/12/03 23:10:48 Hans_Graves]
|
|
*
|
|
* Revision 1.1.6.20 1996/12/03 00:08:36 Hans_Graves
|
|
* Handling of End Of Sequence points. Added PERCENT100 support.
|
|
* [1996/12/03 00:06:06 Hans_Graves]
|
|
*
|
|
* Revision 1.1.6.19 1996/11/18 23:07:38 Hans_Graves
|
|
* Make use of presentation timestamps. Make seeking time-based.
|
|
* [1996/11/18 22:48:00 Hans_Graves]
|
|
*
|
|
* Revision 1.1.6.18 1996/11/14 22:32:10 Hans_Graves
|
|
* AUDIOCHANNELS can only be changed under AC3 decompression.
|
|
* [1996/11/14 22:31:39 Hans_Graves]
|
|
*
|
|
* Revision 1.1.6.17 1996/11/14 21:49:29 Hans_Graves
|
|
* Multichannel setting using AUDIOCHANNELS param.
|
|
* [1996/11/14 21:44:44 Hans_Graves]
|
|
*
|
|
* Revision 1.1.6.16 1996/11/11 18:21:10 Hans_Graves
|
|
* Added SlibGetParamString() support for SLIB_PARAM_TYPE.
|
|
* [1996/11/11 18:01:25 Hans_Graves]
|
|
*
|
|
* Revision 1.1.6.15 1996/11/08 21:51:08 Hans_Graves
|
|
* Added new PARAMs VIDEOMAINSTREAM, AUDIOMAINSTREAM and TYPE
|
|
* [1996/11/08 21:31:08 Hans_Graves]
|
|
*
|
|
* Revision 1.1.6.14 1996/10/28 17:32:34 Hans_Graves
|
|
* MME-1402, 1431, 1435: Timestamp related changes.
|
|
* [1996/10/28 17:23:07 Hans_Graves]
|
|
*
|
|
* Revision 1.1.6.13 1996/10/17 00:23:36 Hans_Graves
|
|
* Added SLIB_PARAM_VIDEOFRAME and SLIB_PARAM_FRAMEDURATION.
|
|
* [1996/10/17 00:19:44 Hans_Graves]
|
|
*
|
|
* Revision 1.1.6.12 1996/10/12 17:18:56 Hans_Graves
|
|
* Added SLIB_PARAM_SKIPPEL and SLIB_PARAM_HALFPEL support.
|
|
* [1996/10/12 17:02:37 Hans_Graves]
|
|
*
|
|
* Revision 1.1.6.11 1996/10/03 19:14:26 Hans_Graves
|
|
* Added Presentation and Decoding timestamp support.
|
|
* [1996/10/03 19:10:42 Hans_Graves]
|
|
*
|
|
* Revision 1.1.6.10 1996/09/29 22:19:44 Hans_Graves
|
|
* Added STRIDE param.
|
|
* [1996/09/29 21:31:34 Hans_Graves]
|
|
*
|
|
* Revision 1.1.6.9 1996/09/25 19:16:50 Hans_Graves
|
|
* Added SLIB_INTERNAL define.
|
|
* [1996/09/25 19:01:56 Hans_Graves]
|
|
*
|
|
* Revision 1.1.6.8 1996/09/23 18:04:05 Hans_Graves
|
|
* Added STATS params.
|
|
* [1996/09/23 17:58:54 Hans_Graves]
|
|
*
|
|
* Revision 1.1.6.7 1996/09/18 23:47:17 Hans_Graves
|
|
* Added new PARAMs: VBV, ASPECTRATIO, TIMECODE, VERSION
|
|
* [1996/09/18 22:07:17 Hans_Graves]
|
|
*
|
|
* Revision 1.1.6.6 1996/08/09 20:51:53 Hans_Graves
|
|
* Allows deselecting of SLIB_PARAM_VIDEOSTREAMS and SLIB_PARAM_AUDIOSTREAMS
|
|
* [1996/08/09 20:12:16 Hans_Graves]
|
|
*
|
|
* Revision 1.1.6.5 1996/07/30 20:25:38 Wei_Hsu
|
|
* Add motion algorithm param.
|
|
* [1996/07/30 15:59:07 Wei_Hsu]
|
|
*
|
|
* Revision 1.1.6.4 1996/07/19 02:11:17 Hans_Graves
|
|
* Added SLIB_PARAM_DEBUG support
|
|
* [1996/07/19 01:59:50 Hans_Graves]
|
|
*
|
|
* Revision 1.1.6.3 1996/05/23 18:46:38 Hans_Graves
|
|
* Merge MME-1220 & MME-1221 - Multiply MPEG audio bitrates by 1000 instead of 1024
|
|
* [1996/05/23 18:46:09 Hans_Graves]
|
|
*
|
|
* Revision 1.1.6.2 1996/05/10 21:17:47 Hans_Graves
|
|
* Allow FILESIZE param to be set, for callbacks.
|
|
* [1996/05/10 20:46:23 Hans_Graves]
|
|
*
|
|
* Revision 1.1.4.13 1996/04/30 17:05:35 Hans_Graves
|
|
* Report SlibErrorSettingNotEqual correctly under SetParamFloat(). Fixes MME-01173
|
|
* [1996/04/30 16:49:06 Hans_Graves]
|
|
*
|
|
* Revision 1.1.4.12 1996/04/24 22:33:48 Hans_Graves
|
|
* MPEG encoding bitrate fixups.
|
|
* [1996/04/24 22:27:16 Hans_Graves]
|
|
*
|
|
* Revision 1.1.4.11 1996/04/23 21:01:42 Hans_Graves
|
|
* Fix SlibValidateParams(). Add error checking for SlibErrorSettingNotEqual
|
|
* [1996/04/23 20:59:03 Hans_Graves]
|
|
*
|
|
* Revision 1.1.4.10 1996/04/22 15:04:54 Hans_Graves
|
|
* Added SlibValidateParams()
|
|
* [1996/04/22 14:43:04 Hans_Graves]
|
|
*
|
|
* Revision 1.1.4.9 1996/04/19 21:52:26 Hans_Graves
|
|
* Fix BITRATE parameter settings
|
|
* [1996/04/19 21:47:01 Hans_Graves]
|
|
*
|
|
* Revision 1.1.4.8 1996/04/11 14:14:12 Hans_Graves
|
|
* Fix NT warnings
|
|
* [1996/04/11 14:10:21 Hans_Graves]
|
|
*
|
|
* Revision 1.1.4.7 1996/04/10 21:47:43 Hans_Graves
|
|
* Added params: FASTENCODE, FASTDECODE, and QUALITY
|
|
* [1996/04/10 21:40:18 Hans_Graves]
|
|
*
|
|
* Revision 1.1.4.6 1996/04/09 16:04:43 Hans_Graves
|
|
* Handle setting negative Height
|
|
* [1996/04/09 14:42:13 Hans_Graves]
|
|
*
|
|
* Revision 1.1.4.5 1996/04/01 19:07:57 Hans_Graves
|
|
* And some error checking
|
|
* [1996/04/01 19:04:40 Hans_Graves]
|
|
*
|
|
* Revision 1.1.4.4 1996/04/01 16:23:17 Hans_Graves
|
|
* NT porting
|
|
* [1996/04/01 16:16:03 Hans_Graves]
|
|
*
|
|
* Revision 1.1.4.3 1996/03/12 16:15:54 Hans_Graves
|
|
* Added SLIB_PARAM_FILEBUFSIZE param
|
|
* [1996/03/12 15:54:22 Hans_Graves]
|
|
*
|
|
* Revision 1.1.4.2 1996/03/08 18:46:49 Hans_Graves
|
|
* Added SlibGetParamString()
|
|
* [1996/03/08 18:34:51 Hans_Graves]
|
|
*
|
|
* Revision 1.1.2.6 1996/02/07 23:23:59 Hans_Graves
|
|
* Added SEEK_EXACT. Fixed most frame counting problems.
|
|
* [1996/02/07 23:20:37 Hans_Graves]
|
|
*
|
|
* Revision 1.1.2.5 1996/02/06 22:54:08 Hans_Graves
|
|
* Seek fix-ups. More accurate MPEG frame counts.
|
|
* [1996/02/06 22:45:21 Hans_Graves]
|
|
*
|
|
* Revision 1.1.2.4 1996/02/02 17:36:05 Hans_Graves
|
|
* Enhanced audio info. Cleaned up API
|
|
* [1996/02/02 17:29:49 Hans_Graves]
|
|
*
|
|
* Revision 1.1.2.3 1996/01/15 16:26:32 Hans_Graves
|
|
* Added Audio Params
|
|
* [1996/01/15 15:48:20 Hans_Graves]
|
|
*
|
|
* Revision 1.1.2.2 1996/01/11 16:17:35 Hans_Graves
|
|
* First time under SLIB
|
|
* [1996/01/11 16:11:45 Hans_Graves]
|
|
*
|
|
* $EndLog$
|
|
*/
|
|
/*****************************************************************************
|
|
** Copyright (c) Digital Equipment Corporation, 1995 **
|
|
** **
|
|
** All Rights Reserved. Unpublished rights reserved under the copyright **
|
|
** laws of the United States. **
|
|
** **
|
|
** The software contained on this media is proprietary to and embodies **
|
|
** the confidential technology of Digital Equipment Corporation. **
|
|
** Possession, use, duplication or dissemination of the software and **
|
|
** media is authorized only pursuant to a valid written license from **
|
|
** Digital Equipment Corporation. **
|
|
** **
|
|
** RESTRICTED RIGHTS LEGEND Use, duplication, or disclosure by the U.S. **
|
|
** Government is subject to restrictions as set forth in Subparagraph **
|
|
** (c)(1)(ii) of DFARS 252.227-7013, or in FAR 52.227-19, as applicable. **
|
|
******************************************************************************/
|
|
|
|
/*
|
|
#define _SLIBDEBUG_
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#ifdef WIN32
|
|
#include <time.h>
|
|
#include <sys/timeb.h>
|
|
#else
|
|
#include <sys/time.h>
|
|
#endif /* WIN32 */
|
|
#define SLIB_INTERNAL
|
|
#include "slib.h"
|
|
#include "SC_err.h"
|
|
|
|
#ifdef _SLIBDEBUG_
|
|
#define _DEBUG_ 1 /* detailed debuging statements */
|
|
#define _VERBOSE_ 1 /* show progress */
|
|
#define _VERIFY_ 1 /* verify correct operation */
|
|
#define _WARN_ 1 /* warnings about strange behavior */
|
|
#endif
|
|
|
|
static float _version = 2.10F;
|
|
static char _version_date[] = { __DATE__ };
|
|
|
|
SlibTime_t slibGetSystemTime()
|
|
{
|
|
SlibTime_t mstime;
|
|
#ifdef WIN32
|
|
struct _timeb t ;
|
|
_ftime(&t);
|
|
mstime = (SlibTime_t)(t.time * 1000 + t.millitm);
|
|
#else
|
|
struct timeval t;
|
|
struct timezone tz;
|
|
|
|
gettimeofday(&t, &tz);
|
|
mstime = (SlibTime_t)(t.tv_sec * 1000 + t.tv_usec / 1000);
|
|
#endif
|
|
return(mstime);
|
|
}
|
|
|
|
qword SlibGetFrameNumber(SlibHandle_t handle, SlibStream_t stream)
|
|
{
|
|
SlibInfo_t *Info=(SlibInfo_t *)handle;
|
|
if (Info && Info->FramesPerSec>0.0F)
|
|
return(slibTimeToFrame(Info, Info->VideoTimeStamp
|
|
+(Info->VideoFrameDuration/200)));
|
|
else
|
|
return((qword)-1);
|
|
}
|
|
|
|
SlibTime_t SlibGetVideoTime(SlibHandle_t handle, SlibStream_t stream)
|
|
{
|
|
if (!handle)
|
|
return(0);
|
|
return((long)((SlibInfo_t *)handle)->VideoTimeStamp);
|
|
}
|
|
|
|
SlibTime_t SlibGetAudioTime(SlibHandle_t handle, SlibStream_t stream)
|
|
{
|
|
if (!handle)
|
|
return(0);
|
|
return((long)((SlibInfo_t *)handle)->AudioTimeStamp);
|
|
}
|
|
|
|
SlibBoolean_t SlibCanSetParam(SlibHandle_t handle, SlibStream_t stream,
|
|
SlibParameter_t param)
|
|
{
|
|
return(TRUE);
|
|
}
|
|
|
|
SlibBoolean_t SlibCanGetParam(SlibHandle_t handle, SlibStream_t stream,
|
|
SlibParameter_t param)
|
|
{
|
|
return(TRUE);
|
|
}
|
|
|
|
SlibStatus_t SlibSetParamInt(SlibHandle_t handle, SlibStream_t stream,
|
|
SlibParameter_t param, long value)
|
|
{
|
|
SlibInfo_t *Info=(SlibInfo_t *)handle;
|
|
SlibStatus_t status=SlibErrorNone;
|
|
long actvalue=value;
|
|
if (!handle)
|
|
return(SlibErrorBadHandle);
|
|
_SlibDebug(_DEBUG_, printf("SlibSetParamInt(stream=%d, param=%d, %d)\n",
|
|
stream, param, value) );
|
|
switch (param)
|
|
{
|
|
case SLIB_PARAM_FPS:
|
|
_SlibDebug(_DEBUG_, printf("SlibSetParamInt(SLIB_PARAM_FPS)\n") );
|
|
status=SlibSetParamFloat(handle, stream, param, (float)value);
|
|
break;
|
|
case SLIB_PARAM_BITRATE:
|
|
_SlibDebug(_DEBUG_,
|
|
printf("SlibSetParamInt(SLIB_PARAM_BITRATE, %d)\n", value) );
|
|
if (stream==SLIB_STREAM_MAINAUDIO)
|
|
status=SlibSetParamInt(handle, stream, SLIB_PARAM_AUDIOBITRATE,
|
|
value);
|
|
else if (stream==SLIB_STREAM_MAINVIDEO)
|
|
status=SlibSetParamInt(handle, stream, SLIB_PARAM_VIDEOBITRATE,
|
|
value);
|
|
else /* setting overall bitrate: try to calc best audio+video rates */
|
|
{
|
|
long vbitrate=value;
|
|
/* spread total bitrate across all streams */
|
|
if (Info->AudioStreams)
|
|
{
|
|
long abitrate=Info->VideoStreams ? (value*Info->Channels)/10
|
|
: value;
|
|
/* don't set bitrates higher than necessary */
|
|
if (Info->Channels==1 && abitrate>112*1000)
|
|
abitrate=112*1000;
|
|
else if (abitrate>192*1000)
|
|
abitrate=192*1000;
|
|
status=SlibSetParamInt(handle, stream, SLIB_PARAM_AUDIOBITRATE,
|
|
abitrate);
|
|
abitrate=SlibGetParamInt(handle, stream, SLIB_PARAM_AUDIOBITRATE);
|
|
vbitrate=value-abitrate; /* subtract bitrate allocated to audio */
|
|
}
|
|
if (Info->VideoStreams)
|
|
status=SlibSetParamInt(handle, stream, SLIB_PARAM_VIDEOBITRATE,
|
|
vbitrate);
|
|
slibValidateBitrates(Info); /* check the bitrate setting */
|
|
if (Info->VideoStreams && Info->TotalBitRate>value)
|
|
{
|
|
/*
|
|
* Since the total bitrate is over the desired bitrate
|
|
* subtract the difference from the video bitrate
|
|
*/
|
|
vbitrate=Info->VideoBitRate-(Info->TotalBitRate-value);
|
|
status=SlibSetParamInt(handle, stream, SLIB_PARAM_VIDEOBITRATE,
|
|
vbitrate);
|
|
}
|
|
}
|
|
slibValidateBitrates(Info);
|
|
actvalue=Info->TotalBitRate;
|
|
_SlibDebug(_DEBUG_,
|
|
printf("MuxBitRate=%d TotalBitRate=%d abitrate=%d vbitrate=%d\n",
|
|
Info->MuxBitRate, Info->TotalBitRate,
|
|
SlibGetParamInt(handle, stream, SLIB_PARAM_AUDIOBITRATE),
|
|
SlibGetParamInt(handle, stream, SLIB_PARAM_VIDEOBITRATE) ) );
|
|
break;
|
|
case SLIB_PARAM_VIDEOBITRATE:
|
|
_SlibDebug(_DEBUG_,
|
|
printf("SlibSetParamInt(SLIB_PARAM_VIDEOBITRATE, %d)\n", value) );
|
|
if (Info->Svh)
|
|
{
|
|
SvSetParamInt(Info->Svh, SV_PARAM_BITRATE, value);
|
|
actvalue=(long)SvGetParamInt(Info->Svh, SV_PARAM_BITRATE);
|
|
}
|
|
if (actvalue>0)
|
|
Info->VideoBitRate=actvalue;
|
|
slibValidateBitrates(Info);
|
|
break;
|
|
case SLIB_PARAM_VIDEOSTREAMS:
|
|
if (Info->VideoStreams!=(int)value)
|
|
{
|
|
Info->VideoStreams=(int)value;
|
|
if (Info->VideoStreams)
|
|
slibAddPin(Info, SLIB_DATA_VIDEO, "Video");
|
|
else
|
|
{
|
|
slibPinPrepareReposition(Info, SLIB_DATA_VIDEO);
|
|
slibRemovePin(Info, SLIB_DATA_VIDEO);
|
|
}
|
|
}
|
|
break;
|
|
case SLIB_PARAM_MOTIONALG:
|
|
if (Info->Svh)
|
|
SvSetParamInt(Info->Svh, SV_PARAM_MOTIONALG, value);
|
|
break;
|
|
case SLIB_PARAM_ALGFLAGS:
|
|
if (Info->Svh)
|
|
SvSetParamInt(Info->Svh, SV_PARAM_ALGFLAGS, value);
|
|
break;
|
|
case SLIB_PARAM_MOTIONSEARCH:
|
|
if (Info->Svh)
|
|
SvSetParamInt(Info->Svh, SV_PARAM_MOTIONSEARCH, value);
|
|
break;
|
|
case SLIB_PARAM_MOTIONTHRESH:
|
|
if (Info->Svh)
|
|
SvSetParamInt(Info->Svh, SV_PARAM_MOTIONTHRESH, value);
|
|
break;
|
|
case SLIB_PARAM_QUANTI:
|
|
if (Info->Svh)
|
|
SvSetParamInt(Info->Svh, SV_PARAM_QUANTI, value);
|
|
break;
|
|
case SLIB_PARAM_QUANTP:
|
|
if (Info->Svh)
|
|
SvSetParamInt(Info->Svh, SV_PARAM_QUANTP, value);
|
|
break;
|
|
case SLIB_PARAM_QUANTB:
|
|
if (Info->Svh)
|
|
SvSetParamInt(Info->Svh, SV_PARAM_QUANTB, value);
|
|
break;
|
|
case SLIB_PARAM_KEYSPACING:
|
|
if (Info->Svh)
|
|
SvSetParamInt(Info->Svh, SV_PARAM_KEYSPACING, value);
|
|
break;
|
|
case SLIB_PARAM_SUBKEYSPACING:
|
|
if (Info->Svh)
|
|
SvSetParamInt(Info->Svh, SV_PARAM_SUBKEYSPACING, value);
|
|
break;
|
|
case SLIB_PARAM_FRAMETYPE:
|
|
if (Info->Svh)
|
|
SvSetParamInt(Info->Svh, SV_PARAM_FRAMETYPE, value);
|
|
break;
|
|
case SLIB_PARAM_VIDEOPROGRAM:
|
|
Info->VideoPID=(int)value;
|
|
break;
|
|
case SLIB_PARAM_AUDIOPROGRAM:
|
|
Info->AudioPID=(int)value;
|
|
break;
|
|
case SLIB_PARAM_VIDEOMAINSTREAM:
|
|
Info->VideoMainStream=(int)value;
|
|
break;
|
|
case SLIB_PARAM_AUDIOMAINSTREAM:
|
|
Info->AudioMainStream=(int)value;
|
|
break;
|
|
case SLIB_PARAM_WIDTH:
|
|
_SlibDebug(_DEBUG_,
|
|
printf("SlibSetParamInt(SLIB_PARAM_WIDTH)\n") );
|
|
Info->Width=(short)value;
|
|
if (Info->Mode==SLIB_MODE_COMPRESS && Info->CompVideoFormat)
|
|
Info->CompVideoFormat->biWidth=Info->Width;
|
|
if (Info->Mode==SLIB_MODE_COMPRESS && Info->CodecVideoFormat)
|
|
Info->CodecVideoFormat->biWidth=Info->Width;
|
|
if (Info->VideoFormat)
|
|
Info->VideoFormat->biWidth=Info->Width;
|
|
return(slibValidateVideoParams(Info));
|
|
case SLIB_PARAM_STRIDE:
|
|
_SlibDebug(_DEBUG_,
|
|
printf("SlibSetParamInt(SLIB_PARAM_STRIDE)\n") );
|
|
Info->Stride=(long)value;
|
|
if (Info->Sch && Info->Mode==SLIB_MODE_DECOMPRESS)
|
|
SconSetParamInt(Info->Sch, SCON_OUTPUT, SCON_PARAM_STRIDE, Info->Stride);
|
|
break;
|
|
case SLIB_PARAM_HEIGHT:
|
|
_SlibDebug(_DEBUG_,
|
|
printf("SlibSetParamInt(SLIB_PARAM_HEIGHT)\n") );
|
|
Info->Height=(short)value<0 ? (short)-value : (short)value;
|
|
if (Info->Mode==SLIB_MODE_COMPRESS && Info->CompVideoFormat)
|
|
Info->CompVideoFormat->biHeight=Info->Height;
|
|
if (Info->Mode==SLIB_MODE_COMPRESS && Info->CodecVideoFormat)
|
|
Info->CodecVideoFormat->biHeight=Info->Height;
|
|
if (Info->VideoFormat)
|
|
Info->VideoFormat->biHeight=(short)value;
|
|
return(slibValidateVideoParams(Info));
|
|
case SLIB_PARAM_VIDEOFORMAT:
|
|
_SlibDebug(_DEBUG_,
|
|
printf("SlibSetParamInt(SLIB_PARAM_VIDEOFORMAT, '%c%c%c%c')\n",
|
|
value&0xFF, (value>>8)&0xFF, (value>>16)&0xFF,(value>>24)&0xFF) );
|
|
if (Info->VideoFormat)
|
|
Info->VideoFormat->biCompression=(dword)value;
|
|
#if 0
|
|
if (Info->Mode==SLIB_MODE_COMPRESS && Info->CodecVideoFormat)
|
|
Info->CodecVideoFormat->biCompression=(dword)value;
|
|
#endif
|
|
return(slibValidateVideoParams(Info));
|
|
case SLIB_PARAM_VIDEOBITS:
|
|
_SlibDebug(_DEBUG_,
|
|
printf("SlibSetParamInt(SLIB_PARAM_VIDEOBITS, %d)\n", value) );
|
|
if (Info->VideoFormat)
|
|
Info->VideoFormat->biBitCount=(word)value;
|
|
if (Info->Mode==SLIB_MODE_COMPRESS && Info->CodecVideoFormat)
|
|
Info->CodecVideoFormat->biBitCount=(dword)value;
|
|
return(slibValidateVideoParams(Info));
|
|
case SLIB_PARAM_AUDIOSTREAMS:
|
|
if (Info->AudioStreams!=(int)value)
|
|
{
|
|
Info->AudioStreams=(int)value;
|
|
if (Info->AudioStreams)
|
|
slibAddPin(Info, SLIB_DATA_AUDIO, "Audio");
|
|
else
|
|
{
|
|
slibPinPrepareReposition(Info, SLIB_DATA_AUDIO);
|
|
slibRemovePin(Info, SLIB_DATA_AUDIO);
|
|
}
|
|
}
|
|
break;
|
|
case SLIB_PARAM_AUDIOBITRATE:
|
|
_SlibDebug(_DEBUG_,
|
|
printf("SlibSetParamInt(SLIB_PARAM_AUDIOBITRATE, %d)\n", value) );
|
|
if (Info->Sah)
|
|
{
|
|
SaSetParamInt(Info->Sah, SA_PARAM_BITRATE, value);
|
|
actvalue=(long)SaGetParamInt(Info->Sah, SA_PARAM_BITRATE);
|
|
}
|
|
if (actvalue>0)
|
|
Info->AudioBitRate=actvalue;
|
|
slibValidateBitrates(Info);
|
|
break;
|
|
case SLIB_PARAM_AUDIOCHANNELS:
|
|
if (Info->Mode==SLIB_MODE_COMPRESS ||
|
|
Info->AudioType==SLIB_TYPE_AC3_AUDIO)
|
|
{
|
|
Info->Channels=value;
|
|
if (Info->AudioFormat)
|
|
Info->AudioFormat->nChannels=(word)value;
|
|
SaSetParamInt(Info->Sah, SA_PARAM_CHANNELS, value);
|
|
}
|
|
actvalue=Info->Channels;
|
|
break;
|
|
case SLIB_PARAM_SAMPLESPERSEC:
|
|
{
|
|
unsigned dword nativesps;
|
|
Info->SamplesPerSec=value;
|
|
nativesps=value;
|
|
#ifdef MPEG_SUPPORT
|
|
if (SlibTypeIsMPEG(Info->Type))
|
|
{
|
|
/* choose a MPEG supported native sample rate */
|
|
if (value%11025 == 0) /* multiples of 11025 can be converted */
|
|
nativesps=44100;
|
|
else if (value==48000)
|
|
nativesps=48000;
|
|
else if (value%8000 == 0) /* multiples of 8000 can be converted */
|
|
nativesps=32000;
|
|
}
|
|
#endif /* MPEG_SUPPORT */
|
|
if (Info->AudioFormat)
|
|
Info->AudioFormat->nSamplesPerSec=nativesps;
|
|
}
|
|
break;
|
|
case SLIB_PARAM_NATIVESAMPLESPERSEC:
|
|
if (Info->AudioFormat)
|
|
Info->AudioFormat->nSamplesPerSec=(dword)value;
|
|
break;
|
|
case SLIB_PARAM_BITSPERSAMPLE:
|
|
Info->BitsPerSample=value;
|
|
if (Info->AudioFormat && value==16)
|
|
Info->AudioFormat->wBitsPerSample=(word)value;
|
|
break;
|
|
case SLIB_PARAM_NATIVEBITSPERSAMPLE:
|
|
if (Info->AudioFormat)
|
|
Info->AudioFormat->wBitsPerSample=(word)value;
|
|
break;
|
|
case SLIB_PARAM_VIDEOQUALITY:
|
|
if (Info->Svh)
|
|
SvSetParamInt(Info->Svh, SV_PARAM_QUALITY, (ScBoolean_t)value);
|
|
break;
|
|
case SLIB_PARAM_AUDIOQUALITY:
|
|
if (Info->Sah)
|
|
SaSetParamInt(Info->Sah, SA_PARAM_QUALITY, (ScBoolean_t)value);
|
|
break;
|
|
case SLIB_PARAM_FILESIZE:
|
|
Info->FileSize=(unsigned long)value;
|
|
break;
|
|
case SLIB_PARAM_FILEBUFSIZE:
|
|
Info->FileBufSize=(unsigned dword)value;
|
|
break;
|
|
case SLIB_PARAM_COMPBUFSIZE:
|
|
if (value<=0)
|
|
Info->CompBufSize=(unsigned dword)2*1024; /* default */
|
|
else
|
|
Info->CompBufSize=(unsigned dword)value;
|
|
break;
|
|
case SLIB_PARAM_PACKETSIZE:
|
|
if (Info->Svh)
|
|
SvSetParamInt(Info->Svh, SV_PARAM_PACKETSIZE, value);
|
|
break;
|
|
case SLIB_PARAM_FORMATEXT:
|
|
if (Info->Svh)
|
|
SvSetParamInt(Info->Svh, SV_PARAM_FORMATEXT, value);
|
|
break;
|
|
case SLIB_PARAM_OVERFLOWSIZE:
|
|
Info->OverflowSize=(unsigned long)value;
|
|
break;
|
|
case SLIB_PARAM_DEBUG:
|
|
Info->dbg=(void *)value;
|
|
if (Info->Svh)
|
|
SvSetParamInt(Info->Svh, SV_PARAM_DEBUG, value);
|
|
if (Info->Sah)
|
|
SaSetParamInt(Info->Sah, SA_PARAM_DEBUG, value);
|
|
break;
|
|
default:
|
|
return(SlibErrorUnsupportedParam);
|
|
}
|
|
if (actvalue!=value)
|
|
{
|
|
_SlibDebug(_DEBUG_ || _WARN_,
|
|
printf("SlibSetParamFloat() SettingNotEqual: %ld(req) != %ld(act)\n",
|
|
value, actvalue) );
|
|
return(SlibErrorSettingNotEqual);
|
|
}
|
|
return(status);
|
|
}
|
|
|
|
SlibStatus_t SlibSetParamLong(SlibHandle_t handle, SlibStream_t stream,
|
|
SlibParameter_t param, qword value)
|
|
{
|
|
SlibInfo_t *Info=(SlibInfo_t *)handle;
|
|
SlibStatus_t status=SlibErrorNone;
|
|
qword actvalue=value;
|
|
if (!handle)
|
|
return(SlibErrorBadHandle);
|
|
_SlibDebug(_DEBUG_, printf("SlibSetParamLong(stream=%d, param=%d, %ld)\n",
|
|
stream, param, value) );
|
|
/* this needs to be implemented */
|
|
return(SlibSetParamInt(handle, stream, param, (long)value));
|
|
}
|
|
|
|
SlibStatus_t SlibSetParamFloat(SlibHandle_t handle, SlibStream_t stream,
|
|
SlibParameter_t param, float value)
|
|
{
|
|
SlibInfo_t *Info=(SlibInfo_t *)handle;
|
|
SlibStatus_t status=SlibErrorNone;
|
|
float actvalue=value;
|
|
if (!handle)
|
|
return(SlibErrorBadHandle);
|
|
_SlibDebug(_DEBUG_, printf("SlibSetParamFloat()\n") );
|
|
switch (param)
|
|
{
|
|
case SLIB_PARAM_FPS:
|
|
_SlibDebug(_DEBUG_,
|
|
printf("SlibSetParamFloat(SLIB_PARAM_FPS)\n") );
|
|
if (Info->Svh)
|
|
{
|
|
SvSetParamFloat(Info->Svh, SV_PARAM_FPS, value);
|
|
actvalue=SvGetParamFloat(Info->Svh, SV_PARAM_FPS);
|
|
}
|
|
if (actvalue>0.0F)
|
|
Info->FramesPerSec=actvalue;
|
|
break;
|
|
default:
|
|
return(SlibSetParamInt(handle, stream, param, (long)value));
|
|
}
|
|
if (actvalue>value+(float)0.0000001 ||
|
|
actvalue<value-(float)0.0000001)
|
|
{
|
|
_SlibDebug(_DEBUG_ || _WARN_,
|
|
printf("SlibSetParamFloat() SettingNotEqual: %.3f(req) != %.3f(act)\n",
|
|
value, actvalue) );
|
|
return(SlibErrorSettingNotEqual);
|
|
}
|
|
return(status);
|
|
}
|
|
|
|
SlibStatus_t SlibSetParamBoolean(SlibHandle_t handle, SlibStream_t stream,
|
|
SlibParameter_t param, SlibBoolean_t value)
|
|
{
|
|
SlibInfo_t *Info=(SlibInfo_t *)handle;
|
|
if (!handle)
|
|
return(SlibErrorBadHandle);
|
|
_SlibDebug(_DEBUG_, printf("SlibSetParamFloat()\n") );
|
|
switch (param)
|
|
{
|
|
case SLIB_PARAM_STATS:
|
|
if (value)
|
|
{
|
|
if (Info->stats==NULL)
|
|
{
|
|
Info->stats = (SlibStats_t *)ScAlloc(sizeof(SlibStats_t));
|
|
if (Info->stats==NULL)
|
|
return(SlibErrorMemory);
|
|
SlibSetParamBoolean(handle, stream, SLIB_PARAM_STATS_RESET, TRUE);
|
|
}
|
|
else
|
|
Info->stats->StartTime=slibGetSystemTime();
|
|
Info->stats->Record=TRUE;
|
|
}
|
|
else if (Info->stats)
|
|
{
|
|
Info->stats->Record=FALSE;
|
|
Info->stats->StopTime=slibGetSystemTime();
|
|
}
|
|
break;
|
|
case SLIB_PARAM_STATS_RESET:
|
|
if (Info->stats)
|
|
{
|
|
Info->stats->StartTime=Info->stats->StopTime=
|
|
slibGetSystemTime();
|
|
Info->stats->FramesProcessed=0;
|
|
Info->stats->FramesSkipped=0;
|
|
}
|
|
break;
|
|
case SLIB_PARAM_NEEDACCURACY:
|
|
Info->NeedAccuracy = value ? TRUE : FALSE;
|
|
if (Info->NeedAccuracy && slibHasTimeCode(Info))
|
|
{
|
|
/*
|
|
* We'll seek toward the end of the file so the frame count
|
|
* can be more accurately measured
|
|
*/
|
|
if (!Info->VideoLengthKnown && Info->FileSize>0)
|
|
{
|
|
int minpercent=0, maxpercent=9900, lastpercent=0, trypercent=9900;
|
|
int tries=0;
|
|
unsigned qword newfilesize=Info->FileSize;
|
|
qword stime = Info->VideoTimeStamp;
|
|
SlibStatus_t status;
|
|
if (SlibTimeIsInValid(stime)) stime=0;
|
|
while (!Info->VideoLengthKnown && maxpercent-minpercent>200 && tries<5)
|
|
{
|
|
status=SlibSeekEx(handle, SLIB_STREAM_ALL, SLIB_SEEK_KEY,
|
|
trypercent, SLIB_UNIT_PERCENT100, NULL);
|
|
if (status==SlibErrorEndOfStream)
|
|
break;
|
|
else if (status==SlibErrorNoBeginning)
|
|
{
|
|
/* adjust the file size, data at end must be invalid */
|
|
newfilesize=(Info->FileSize*(trypercent/100))/100;
|
|
lastpercent=trypercent;
|
|
maxpercent=trypercent;
|
|
trypercent=(minpercent+maxpercent)/2; /* try half way between min and max */
|
|
}
|
|
else if (status==SlibErrorNone)
|
|
{
|
|
if (maxpercent-trypercent<=300)
|
|
break;
|
|
else
|
|
{
|
|
lastpercent=trypercent;
|
|
minpercent=trypercent;
|
|
trypercent=(minpercent+maxpercent)/2; /* try half way between min and max */
|
|
}
|
|
}
|
|
else
|
|
{
|
|
lastpercent=trypercent;
|
|
trypercent=((trypercent-minpercent)*3)/4;
|
|
}
|
|
tries++;
|
|
}
|
|
Info->FileSize=newfilesize;
|
|
while (status==SlibErrorNone && !Info->VideoLengthKnown)
|
|
status=SlibSeek(handle, SLIB_STREAM_ALL, SLIB_SEEK_NEXT_KEY, 0);
|
|
SlibSeekEx(handle, SLIB_STREAM_ALL, SLIB_SEEK_KEY, stime,
|
|
SLIB_UNIT_MS, NULL);
|
|
}
|
|
}
|
|
break;
|
|
case SLIB_PARAM_FASTENCODE:
|
|
if (Info->Svh)
|
|
SvSetParamBoolean(Info->Svh, SV_PARAM_FASTENCODE,
|
|
(ScBoolean_t)value);
|
|
if (Info->Sah)
|
|
SvSetParamBoolean(Info->Sah, SV_PARAM_FASTENCODE,
|
|
(ScBoolean_t)value);
|
|
break;
|
|
case SLIB_PARAM_FASTDECODE:
|
|
if (Info->Svh)
|
|
SvSetParamBoolean(Info->Svh, SV_PARAM_FASTDECODE,
|
|
(ScBoolean_t)value);
|
|
if (Info->Sah)
|
|
SvSetParamBoolean(Info->Sah, SV_PARAM_FASTDECODE,
|
|
(ScBoolean_t)value);
|
|
break;
|
|
case SLIB_PARAM_MOTIONALG:
|
|
SlibSetParamInt(handle, stream, param, value?1:0);
|
|
break;
|
|
default:
|
|
return(SlibErrorUnsupportedParam);
|
|
}
|
|
return(SlibErrorNone);
|
|
}
|
|
|
|
SlibStatus_t SlibSetParamStruct(SlibHandle_t handle, SlibStream_t stream,
|
|
SlibParameter_t param,
|
|
void *data, unsigned dword datasize)
|
|
{
|
|
SlibInfo_t *Info=(SlibInfo_t *)handle;
|
|
SlibStatus_t status=SlibErrorNone;
|
|
if (!handle)
|
|
return(SlibErrorBadHandle);
|
|
if (data==NULL || datasize==0)
|
|
return(SlibErrorBadArgument);
|
|
_SlibDebug(_DEBUG_, printf("SlibSetParamStruct(stream=%d, param=%d, data=%p datasize=%ld)\n",
|
|
stream, param, data, datasize) );
|
|
switch (param)
|
|
{
|
|
case SLIB_PARAM_VIDEOFORMAT:
|
|
{
|
|
BITMAPINFOHEADER *bmh=(BITMAPINFOHEADER *)data;
|
|
_SlibDebug(_DEBUG_,
|
|
printf("SlibSetParamStruct(SLIB_PARAM_VIDEOFORMAT)\n") );
|
|
if (Info->VideoFormat==NULL || Info->VideoFormat->biSize<datasize)
|
|
{
|
|
ScFree(Info->VideoFormat);
|
|
Info->VideoFormat=NULL;
|
|
}
|
|
if (Info->VideoFormat==NULL)
|
|
Info->VideoFormat=(BITMAPINFOHEADER *)ScAlloc(datasize);
|
|
Info->Width=(word)bmh->biWidth;
|
|
Info->Height=abs(bmh->biHeight);
|
|
if (Info->VideoFormat)
|
|
{
|
|
memcpy(Info->VideoFormat, bmh, datasize);
|
|
return(slibValidateVideoParams(Info));
|
|
}
|
|
else
|
|
return(SlibErrorMemory);
|
|
}
|
|
default:
|
|
return(SlibErrorUnsupportedParam);
|
|
}
|
|
/* this needs to be implemented */
|
|
return(SlibErrorNone);
|
|
}
|
|
|
|
long SlibGetParamInt(SlibHandle_t handle, SlibStream_t stream,
|
|
SlibParameter_t param)
|
|
{
|
|
SlibInfo_t *Info=(SlibInfo_t *)handle;
|
|
if (!handle)
|
|
return(0);
|
|
switch (param)
|
|
{
|
|
case SLIB_PARAM_TYPE:
|
|
if (stream==SLIB_STREAM_MAINAUDIO)
|
|
return((long)Info->AudioType);
|
|
else if (stream==SLIB_STREAM_MAINVIDEO)
|
|
return((long)Info->VideoType);
|
|
else
|
|
return((long)Info->Type);
|
|
break;
|
|
case SLIB_PARAM_FPS:
|
|
return((long)Info->FramesPerSec);
|
|
break;
|
|
case SLIB_PARAM_BITRATE:
|
|
return((long)Info->TotalBitRate);
|
|
case SLIB_PARAM_VIDEOBITRATE:
|
|
return((long)Info->VideoBitRate);
|
|
case SLIB_PARAM_WIDTH:
|
|
return((long)Info->Width);
|
|
case SLIB_PARAM_HEIGHT:
|
|
return((long)Info->Height);
|
|
case SLIB_PARAM_STRIDE:
|
|
return((long)Info->Stride);
|
|
case SLIB_PARAM_NATIVEWIDTH:
|
|
if (Info->CompVideoFormat)
|
|
return((long)Info->CompVideoFormat->biWidth);
|
|
else
|
|
return((long)Info->Width);
|
|
case SLIB_PARAM_NATIVEHEIGHT:
|
|
if (Info->CompVideoFormat)
|
|
return((long)Info->CompVideoFormat->biHeight);
|
|
else
|
|
return((long)Info->Height);
|
|
case SLIB_PARAM_NATIVEVIDEOFORMAT:
|
|
{
|
|
long format=(long)SvGetParamInt(Info->Svh, SV_PARAM_NATIVEFORMAT);
|
|
if (format==0)
|
|
format=Info->CodecVideoFormat
|
|
? Info->CodecVideoFormat->biCompression
|
|
: Info->VideoFormat->biCompression;
|
|
return(format);
|
|
}
|
|
case SLIB_PARAM_IMAGESIZE:
|
|
return((long)Info->ImageSize);
|
|
case SLIB_PARAM_MININPUTSIZE:
|
|
{
|
|
long size=0;
|
|
if (Info->Mode==SLIB_MODE_COMPRESS)
|
|
{
|
|
if (slibHasVideo(Info))
|
|
size+=Info->ImageSize;
|
|
if (slibHasAudio(Info))
|
|
switch (Info->AudioType)
|
|
{
|
|
case SLIB_TYPE_G723:
|
|
size+=480;
|
|
break;
|
|
default:
|
|
if (Info->AudioFormat)
|
|
size+=Info->AudioFormat->nBlockAlign;
|
|
}
|
|
}
|
|
else if (Info->Mode==SLIB_MODE_DECOMPRESS)
|
|
{
|
|
if (slibHasVideo(Info))
|
|
switch (Info->AudioType)
|
|
{
|
|
case SLIB_TYPE_H263:
|
|
size+=Info->VideoBitRate>0?(Info->VideoBitRate/8):(64*1024);
|
|
break;
|
|
default:
|
|
size+=Info->VideoBitRate>0?(Info->VideoBitRate/8):(64*1024);
|
|
}
|
|
if (slibHasAudio(Info))
|
|
switch (Info->AudioType)
|
|
{
|
|
case SLIB_TYPE_G723:
|
|
size+=(Info->AudioBitRate>=6000)?24:20;
|
|
break;
|
|
default:
|
|
if (Info->AudioFormat)
|
|
size+=Info->AudioFormat->nBlockAlign;
|
|
}
|
|
}
|
|
return(size);
|
|
}
|
|
break;
|
|
case SLIB_PARAM_INPUTSIZE:
|
|
{
|
|
long size=0;
|
|
size+=SlibGetParamInt(handle, stream, SLIB_PARAM_MININPUTSIZE);
|
|
if (size<=8) size=8*1024;
|
|
if (Info->Mode==SLIB_MODE_DECOMPRESS)
|
|
{
|
|
if (slibHasVideo(Info))
|
|
switch (Info->Type) /* add in bytes for header */
|
|
{
|
|
case SLIB_TYPE_AVI: size+=64; break;
|
|
}
|
|
if (slibHasAudio(Info))
|
|
{
|
|
if (!Info->HeaderProcessed) /* add in header */
|
|
switch (Info->Type)
|
|
{
|
|
case SLIB_TYPE_PCM_WAVE: size+=40; break;
|
|
}
|
|
}
|
|
}
|
|
return(size);
|
|
}
|
|
break;
|
|
case SLIB_PARAM_VIDEOFRAME:
|
|
if (Info->FramesPerSec)
|
|
return((long)slibTimeToFrame(Info, Info->VideoTimeStamp
|
|
+(Info->VideoFrameDuration/200)));
|
|
break;
|
|
case SLIB_PARAM_FRAMEDURATION:
|
|
if (Info->FramesPerSec)
|
|
return((long)(10000000L/Info->FramesPerSec));
|
|
else
|
|
return((long)0);
|
|
case SLIB_PARAM_VIDEOFORMAT:
|
|
if (Info->VideoFormat)
|
|
return((long)Info->VideoFormat->biCompression);
|
|
else
|
|
return(0L);
|
|
break;
|
|
case SLIB_PARAM_VIDEOBITS:
|
|
if (Info->VideoFormat)
|
|
return((long)Info->VideoFormat->biBitCount);
|
|
else
|
|
return(0L);
|
|
case SLIB_PARAM_VIDEOPROGRAM:
|
|
return((long)Info->VideoPID);
|
|
case SLIB_PARAM_AUDIOPROGRAM:
|
|
return((long)Info->AudioPID);
|
|
case SLIB_PARAM_VIDEOMAINSTREAM:
|
|
return((long)Info->VideoMainStream);
|
|
case SLIB_PARAM_AUDIOMAINSTREAM:
|
|
return((long)Info->AudioMainStream);
|
|
case SLIB_PARAM_KEYSPACING:
|
|
if (Info->Svh)
|
|
return((long)SvGetParamInt(Info->Svh, SV_PARAM_KEYSPACING));
|
|
else
|
|
return((long)Info->KeySpacing);
|
|
case SLIB_PARAM_SUBKEYSPACING:
|
|
if (Info->Svh)
|
|
return((long)SvGetParamInt(Info->Svh, SV_PARAM_SUBKEYSPACING));
|
|
else
|
|
return((long)Info->SubKeySpacing);
|
|
case SLIB_PARAM_AUDIOFORMAT:
|
|
if (Info->AudioFormat)
|
|
return((long)Info->AudioFormat->wFormatTag);
|
|
else
|
|
return(0);
|
|
break;
|
|
case SLIB_PARAM_AUDIOBITRATE:
|
|
if (Info->AudioBitRate==0 && Info->Sah)
|
|
Info->AudioBitRate=(dword)SaGetParamInt(Info->Sah, SA_PARAM_BITRATE);
|
|
return((long)Info->AudioBitRate);
|
|
case SLIB_PARAM_VIDEOSTREAMS:
|
|
return((long)Info->VideoStreams);
|
|
case SLIB_PARAM_AUDIOSTREAMS:
|
|
return((long)Info->AudioStreams);
|
|
case SLIB_PARAM_AUDIOCHANNELS:
|
|
return((long)Info->Channels);
|
|
case SLIB_PARAM_SAMPLESPERSEC:
|
|
return((long)Info->SamplesPerSec);
|
|
case SLIB_PARAM_NATIVESAMPLESPERSEC:
|
|
if (Info->AudioFormat)
|
|
return((long)Info->AudioFormat->nSamplesPerSec);
|
|
break;
|
|
case SLIB_PARAM_BITSPERSAMPLE:
|
|
return((long)Info->BitsPerSample);
|
|
case SLIB_PARAM_NATIVEBITSPERSAMPLE:
|
|
if (Info->AudioFormat)
|
|
return((long)Info->AudioFormat->wBitsPerSample);
|
|
break;
|
|
case SLIB_PARAM_FILESIZE:
|
|
return((long)Info->FileSize);
|
|
case SLIB_PARAM_FILEBUFSIZE:
|
|
return((long)Info->FileBufSize);
|
|
case SLIB_PARAM_COMPBUFSIZE:
|
|
return((long)Info->CompBufSize);
|
|
case SLIB_PARAM_OVERFLOWSIZE:
|
|
return((long)Info->OverflowSize);
|
|
case SLIB_PARAM_VIDEOQUALITY:
|
|
if (Info->Svh)
|
|
return((long)SvGetParamInt(Info->Svh, SV_PARAM_QUALITY));
|
|
break;
|
|
case SLIB_PARAM_AUDIOQUALITY:
|
|
if (Info->Sah)
|
|
return((long)SaGetParamInt(Info->Sah, SA_PARAM_QUALITY));
|
|
break;
|
|
case SLIB_PARAM_VBVBUFFERSIZE:
|
|
{
|
|
dword vbv;
|
|
if (Info->Svh)
|
|
vbv=(dword)SvGetParamInt(Info->Svh, SV_PARAM_VBVBUFFERSIZE);
|
|
if (vbv<=0)
|
|
vbv=Info->VBVbufSize;
|
|
return(vbv);
|
|
}
|
|
case SLIB_PARAM_VBVDELAY:
|
|
if (Info->Svh)
|
|
return((long)SvGetParamInt(Info->Svh, SV_PARAM_VBVDELAY));
|
|
break;
|
|
case SLIB_PARAM_MOTIONALG:
|
|
if (Info->Svh)
|
|
return((long)SvGetParamInt(Info->Svh, SV_PARAM_MOTIONALG));
|
|
break;
|
|
case SLIB_PARAM_ALGFLAGS:
|
|
if (Info->Svh)
|
|
return((long)SvGetParamInt(Info->Svh, SV_PARAM_ALGFLAGS));
|
|
break;
|
|
case SLIB_PARAM_MOTIONSEARCH:
|
|
if (Info->Svh)
|
|
return((long)SvGetParamInt(Info->Svh, SV_PARAM_MOTIONSEARCH));
|
|
break;
|
|
case SLIB_PARAM_MOTIONTHRESH:
|
|
if (Info->Svh)
|
|
return((long)SvGetParamInt(Info->Svh, SV_PARAM_MOTIONTHRESH));
|
|
break;
|
|
case SLIB_PARAM_PACKETSIZE:
|
|
if (Info->Svh)
|
|
return((long)SvGetParamInt(Info->Svh, SV_PARAM_PACKETSIZE));
|
|
break;
|
|
case SLIB_PARAM_FORMATEXT:
|
|
if (Info->Svh)
|
|
return((long)SvGetParamInt(Info->Svh, SV_PARAM_FORMATEXT));
|
|
break;
|
|
case SLIB_PARAM_QUANTI:
|
|
if (Info->Svh)
|
|
return((long)SvGetParamInt(Info->Svh, SV_PARAM_QUANTI));
|
|
break;
|
|
case SLIB_PARAM_QUANTP:
|
|
if (Info->Svh)
|
|
return((long)SvGetParamInt(Info->Svh, SV_PARAM_QUANTP));
|
|
break;
|
|
case SLIB_PARAM_QUANTB:
|
|
if (Info->Svh)
|
|
return((long)SvGetParamInt(Info->Svh, SV_PARAM_QUANTB));
|
|
break;
|
|
case SLIB_PARAM_FRAMETYPE:
|
|
if (Info->Svh)
|
|
return((long)SvGetParamInt(Info->Svh, SV_PARAM_FRAMETYPE));
|
|
break;
|
|
case SLIB_PARAM_STATS_FPS:
|
|
return((long)SlibGetParamFloat(handle, stream, SLIB_PARAM_STATS_FPS));
|
|
default:
|
|
return((long)SlibGetParamLong(handle, stream, param));
|
|
}
|
|
return(0);
|
|
}
|
|
|
|
qword SlibGetParamLong(SlibHandle_t handle, SlibStream_t stream,
|
|
SlibParameter_t param)
|
|
{
|
|
SlibInfo_t *Info=(SlibInfo_t *)handle;
|
|
if (!handle)
|
|
return((qword)0);
|
|
switch (param)
|
|
{
|
|
case SLIB_PARAM_VIDEOFRAMES:
|
|
if (Info->FramesPerSec)
|
|
return(slibTimeToFrame(Info, Info->VideoLength
|
|
+(Info->VideoFrameDuration/200)));
|
|
break;
|
|
case SLIB_PARAM_VIDEOLENGTH:
|
|
return(Info->VideoLength);
|
|
case SLIB_PARAM_AUDIOLENGTH:
|
|
return((long)Info->AudioLength);
|
|
case SLIB_PARAM_STATS_TIME:
|
|
if (Info->stats)
|
|
{
|
|
if (Info->stats->Record) /* still recording */
|
|
Info->stats->StopTime=slibGetSystemTime();
|
|
return((long)(Info->stats->StopTime-Info->stats->StartTime));
|
|
}
|
|
break;
|
|
case SLIB_PARAM_STATS_FRAMESPROCESSED:
|
|
if (Info->stats)
|
|
return(Info->stats->FramesProcessed);
|
|
break;
|
|
case SLIB_PARAM_STATS_FRAMESSKIPPED:
|
|
if (Info->stats)
|
|
return(Info->stats->FramesSkipped);
|
|
break;
|
|
case SLIB_PARAM_STATS_FRAMES:
|
|
if (Info->stats)
|
|
return(Info->stats->FramesSkipped+
|
|
Info->stats->FramesProcessed);
|
|
break;
|
|
case SLIB_PARAM_TIMECODE:
|
|
if (Info->Svh)
|
|
return(SvGetParamInt(Info->Svh, SV_PARAM_TIMECODE));
|
|
break;
|
|
case SLIB_PARAM_CALCTIMECODE:
|
|
if (Info->Svh)
|
|
return(SvGetParamInt(Info->Svh, SV_PARAM_CALCTIMECODE));
|
|
break;
|
|
case SLIB_PARAM_PTIMECODE:
|
|
if (stream==SLIB_STREAM_MAINAUDIO)
|
|
return(Info->AudioPTimeCode);
|
|
else if (Info->VideoPTimeCode==SLIB_TIME_NONE && Info->Svh &&
|
|
SvGetParamInt(Info->Svh, SV_PARAM_TIMECODE)>0)
|
|
return(SvGetParamInt(Info->Svh, SV_PARAM_TIMECODE));
|
|
else
|
|
return(Info->VideoPTimeCode);
|
|
case SLIB_PARAM_DTIMECODE:
|
|
if (stream==SLIB_STREAM_MAINAUDIO)
|
|
return(Info->AudioDTimeCode);
|
|
else if (Info->VideoDTimeCode==SLIB_TIME_NONE && Info->Svh &&
|
|
SvGetParamInt(Info->Svh, SV_PARAM_TIMECODE)>0)
|
|
return(SvGetParamInt(Info->Svh, SV_PARAM_TIMECODE));
|
|
else
|
|
return(Info->VideoDTimeCode);
|
|
case SLIB_PARAM_PERCENT100:
|
|
if (Info->FileSize>0)
|
|
{
|
|
ScBitstream_t *bs;
|
|
SlibPosition_t pos=slibGetPinPosition(Info, SLIB_DATA_COMPRESSED);
|
|
/* subtract all the unused data from the input position */
|
|
pos-=slibDataOnPin(Info, SLIB_DATA_VIDEO);
|
|
pos-=slibDataOnPin(Info, SLIB_DATA_AUDIO);
|
|
if ((bs=SvGetDataSource(Info->Svh))!=NULL)
|
|
pos-=ScBSBufferedBytesUnused(bs); /* Video Codec unused bytes */
|
|
if ((bs=SaGetDataSource(Info->Sah))!=NULL)
|
|
pos-=ScBSBufferedBytesUnused(bs); /* Audio Codec unused bytes */
|
|
if (pos>=(SlibPosition_t)Info->FileSize)
|
|
return(10000);
|
|
else if (pos>=0)
|
|
return((pos*10000)/Info->FileSize);
|
|
else
|
|
return(0);
|
|
}
|
|
else
|
|
{
|
|
if (stream==SLIB_STREAM_MAINAUDIO &&
|
|
SlibTimeIsValid(Info->AudioTimeStamp) &&
|
|
Info->AudioLength>0)
|
|
return((Info->AudioTimeStamp*10000)/Info->AudioLength);
|
|
else if (SlibTimeIsValid(Info->VideoTimeStamp)
|
|
&& Info->VideoLength>0)
|
|
return((Info->VideoTimeStamp*10000)/Info->VideoLength);
|
|
}
|
|
return((qword)-1);
|
|
}
|
|
return((qword)0);
|
|
}
|
|
|
|
float SlibGetParamFloat(SlibHandle_t handle, SlibStream_t stream,
|
|
SlibParameter_t param)
|
|
{
|
|
SlibInfo_t *Info=(SlibInfo_t *)handle;
|
|
switch (param)
|
|
{
|
|
case SLIB_PARAM_VERSION:
|
|
return(_version);
|
|
}
|
|
if (!handle)
|
|
return((float)0.0);
|
|
switch (param)
|
|
{
|
|
case SLIB_PARAM_FPS:
|
|
return((float)Info->FramesPerSec);
|
|
case SLIB_PARAM_VIDEOASPECTRATIO:
|
|
if (Info->Svh)
|
|
return(SvGetParamFloat(Info->Svh, SV_PARAM_ASPECTRATIO));
|
|
break;
|
|
case SLIB_PARAM_STATS_FPS:
|
|
if (Info->stats)
|
|
{
|
|
float fps=0.0F;
|
|
if (Info->stats->Record) /* still recording */
|
|
Info->stats->StopTime=slibGetSystemTime();
|
|
if (Info->stats->StartTime<Info->stats->StopTime)
|
|
{
|
|
qword ellapsedtime=Info->stats->StopTime-Info->stats->StartTime;
|
|
fps=(float)(Info->stats->FramesProcessed*1000)/ellapsedtime;
|
|
}
|
|
return(fps);
|
|
}
|
|
else
|
|
return(0.0F);
|
|
}
|
|
return((float)SlibGetParamInt(handle, stream, param));
|
|
}
|
|
|
|
SlibBoolean_t SlibGetParamBoolean(SlibHandle_t handle, SlibStream_t stream,
|
|
SlibParameter_t param)
|
|
{
|
|
SlibInfo_t *Info=(SlibInfo_t *)handle;
|
|
if (!handle)
|
|
return(SlibErrorBadHandle);
|
|
switch (param)
|
|
{
|
|
case SLIB_PARAM_STATS:
|
|
return(Info->stats ? Info->stats->Record : FALSE);
|
|
case SLIB_PARAM_NEEDACCURACY:
|
|
return((SlibBoolean_t)Info->NeedAccuracy);
|
|
case SLIB_PARAM_FASTENCODE:
|
|
if (Info->Svh)
|
|
return((SlibBoolean_t)SvGetParamBoolean(Info->Svh,
|
|
SV_PARAM_FASTENCODE));
|
|
break;
|
|
case SLIB_PARAM_FASTDECODE:
|
|
if (Info->Svh)
|
|
return((SlibBoolean_t)SvGetParamBoolean(Info->Svh,
|
|
SV_PARAM_FASTDECODE));
|
|
break;
|
|
}
|
|
return(FALSE);
|
|
}
|
|
|
|
char *SlibGetParamString(SlibHandle_t handle, SlibStream_t stream,
|
|
SlibParameter_t param)
|
|
{
|
|
SlibInfo_t *Info=(SlibInfo_t *)handle;
|
|
static char result[100];
|
|
strcpy(result, "Unknown");
|
|
switch (param)
|
|
{
|
|
case SLIB_PARAM_VERSION_DATE:
|
|
return(_version_date);
|
|
break;
|
|
}
|
|
if (!handle)
|
|
return(result);
|
|
switch (param)
|
|
{
|
|
case SLIB_PARAM_NATIVEVIDEOFORMAT:
|
|
if (Info->CodecVideoFormat)
|
|
switch(Info->CodecVideoFormat->biCompression)
|
|
{
|
|
case BI_YUY2:
|
|
case BI_DECYUVDIB: strcpy(result, "YUV 4:2:2 Interleaved");
|
|
break;
|
|
case BI_BITFIELDS: strcpy(result, "BITFIELDS");
|
|
break;
|
|
case BI_DECXIMAGEDIB: sprintf(result, "XIMAGE %d",
|
|
Info->VideoFormat->biBitCount);
|
|
break;
|
|
case BI_YU12SEP: strcpy(result, "YUV 4:1:1 Separated");
|
|
break;
|
|
case BI_YU16SEP: strcpy(result, "YUV 4:2:2 Separated");
|
|
break;
|
|
case BI_RGB: sprintf(result, "RGB %d",
|
|
Info->VideoFormat->biBitCount);
|
|
break;
|
|
}
|
|
break;
|
|
case SLIB_PARAM_VIDEOFORMAT:
|
|
if (Info->VideoFormat)
|
|
switch(Info->VideoFormat->biCompression)
|
|
{
|
|
case BI_YUY2:
|
|
case BI_DECYUVDIB: strcpy(result, "YUV 4:2:2 Interleaved");
|
|
break;
|
|
case BI_BITFIELDS: strcpy(result, "BITFIELDS");
|
|
break;
|
|
case BI_DECXIMAGEDIB: sprintf(result, "XIMAGE %d",
|
|
Info->VideoFormat->biBitCount);
|
|
break;
|
|
case BI_YU12SEP: strcpy(result, "YUV 4:1:1 Separated");
|
|
break;
|
|
case BI_YU16SEP: strcpy(result, "YUV 4:2:2 Separated");
|
|
break;
|
|
case BI_RGB: sprintf(result, "RGB %d",
|
|
Info->VideoFormat->biBitCount);
|
|
break;
|
|
}
|
|
break;
|
|
case SLIB_PARAM_AUDIOFORMAT:
|
|
if (Info->AudioFormat)
|
|
switch (Info->AudioFormat->wFormatTag)
|
|
{
|
|
case WAVE_FORMAT_PCM: strcpy(result, "PCM");
|
|
break;
|
|
}
|
|
break;
|
|
case SLIB_PARAM_TYPE:
|
|
if (stream==SLIB_STREAM_MAINAUDIO)
|
|
return(SlibQueryForDesc(SLIB_QUERY_TYPES, Info->AudioType));
|
|
else if (stream==SLIB_STREAM_MAINVIDEO)
|
|
return(SlibQueryForDesc(SLIB_QUERY_TYPES, Info->VideoType));
|
|
else
|
|
return(SlibQueryForDesc(SLIB_QUERY_TYPES, Info->Type));
|
|
break;
|
|
}
|
|
return(result);
|
|
}
|
|
|
|
/*
|
|
** Name: SlibValidateParams
|
|
** Purpose: Ensure that the the Video and Audio parameter settings are
|
|
** valid and supported.
|
|
*/
|
|
SlibStatus_t SlibValidateParams(SlibHandle_t handle)
|
|
{
|
|
SlibInfo_t *Info=(SlibInfo_t *)handle;
|
|
if (Info->VideoStreams>0 && slibValidateVideoParams(Info)!=SlibErrorNone)
|
|
return(slibValidateVideoParams(Info));
|
|
if (Info->AudioStreams>0 && slibValidateAudioParams(Info)!=SlibErrorNone)
|
|
return(slibValidateAudioParams(Info));
|
|
if (Info->Svh)
|
|
{
|
|
SvStatus_t status;
|
|
_SlibDebug(_DEBUG_, printf("SvQuery(%c%c%c%c,%d bits,%dx%d,%c%c%c%c,%d bits,%dx%d)\n",
|
|
(Info->CodecVideoFormat->biCompression)&0xFF,
|
|
(Info->CodecVideoFormat->biCompression>>8)&0xFF,
|
|
(Info->CodecVideoFormat->biCompression>>16)&0xFF,
|
|
(Info->CodecVideoFormat->biCompression>>24)&0xFF,
|
|
Info->CodecVideoFormat->biBitCount,
|
|
Info->CodecVideoFormat->biWidth,
|
|
Info->CodecVideoFormat->biHeight,
|
|
(Info->CompVideoFormat->biCompression)&0xFF,
|
|
(Info->CompVideoFormat->biCompression>>8)&0xFF,
|
|
(Info->CompVideoFormat->biCompression>>16)&0xFF,
|
|
(Info->CompVideoFormat->biCompression>>24)&0xFF,
|
|
Info->CompVideoFormat->biBitCount,
|
|
Info->CompVideoFormat->biWidth,
|
|
Info->CompVideoFormat->biHeight) );
|
|
if (Info->Mode==SLIB_MODE_COMPRESS)
|
|
status=SvCompressQuery(Info->Svh, Info->CodecVideoFormat,
|
|
Info->CompVideoFormat);
|
|
else
|
|
status=SvDecompressQuery(Info->Svh, Info->CompVideoFormat,
|
|
Info->CodecVideoFormat);
|
|
if (status!=NoErrors)
|
|
{
|
|
_SlibDebug(_WARN_, printf("SlibValidateParams() SvQuery failed\n");
|
|
ScGetErrorText(status,0,0) );
|
|
return(SlibErrorUnsupportedFormat);
|
|
}
|
|
}
|
|
if (Info->Sah)
|
|
{
|
|
SaStatus_t status;
|
|
if (Info->Mode==SLIB_MODE_COMPRESS)
|
|
status=SaCompressQuery(Info->Sah, Info->AudioFormat,
|
|
Info->CompAudioFormat);
|
|
else
|
|
status=SaDecompressQuery(Info->Sah, Info->CompAudioFormat,
|
|
Info->AudioFormat);
|
|
if (status!=NoErrors)
|
|
{
|
|
_SlibDebug(_WARN_, printf("SlibValidateParams() SaBegin failed\n");
|
|
ScGetErrorText(status,0,0) );
|
|
return(SlibErrorUnsupportedFormat);
|
|
}
|
|
}
|
|
return(SlibErrorNone);
|
|
}
|
|
|