LocalZynAddSubFx::LocalZynAddSubFx()
{
for( int i = 0; i < NumKeys; ++i )
{
m_runningNotes[i] = 0;
}
if( s_instanceCount == 0 )
{
#ifdef LMMS_BUILD_WIN32
// (non-portable) initialization of statically linked pthread library
pthread_win32_process_attach_np();
pthread_win32_thread_attach_np();
#endif
initConfig();
OSCIL_SIZE = config.cfg.OscilSize;
srand( time( NULL ) );
denormalkillbuf = new REALTYPE[SOUND_BUFFER_SIZE];
for( int i = 0; i < SOUND_BUFFER_SIZE; ++i )
{
denormalkillbuf[i] = (RND-0.5)*1e-16;
}
}
++s_instanceCount;
m_master = new Master();
m_master->swaplr = 0;
}
int main(int argc, char **argv) {
#ifdef MINGW
pthread_win32_thread_attach_np();
#endif
Fl::lock();
MainWindow mainWindow;
mainWindow.show(argc, argv);
ToxWorker *toxWorker;
try {
toxWorker = new ToxWorker(&mainWindow);
} catch (ToxWorkerException &e) {
Dialog::notify("Can't start Tox or ToxTun");
return EXIT_FAILURE;
}
mainWindow.setToxWorker(toxWorker);
Fl::run();
mainWindow.setToxWorker(nullptr);
delete toxWorker;
#ifdef MINGW
pthread_win32_thread_detach_np();
#endif
return EXIT_SUCCESS;
}
/****************************************************************************
* main:
****************************************************************************/
int main( int argc, char **argv )
{
x264_param_t param;
cli_opt_t opt;
int ret;
#ifdef PTW32_STATIC_LIB
pthread_win32_process_attach_np();
pthread_win32_thread_attach_np();
#endif
#ifdef _WIN32
_setmode(_fileno(stdin), _O_BINARY);
_setmode(_fileno(stdout), _O_BINARY);
#endif
x264_param_default( ¶m );
/* Parse command line */
if( Parse( argc, argv, ¶m, &opt ) < 0 )
return -1;
/* Control-C handler */
signal( SIGINT, SigIntHandler );
ret = Encode( ¶m, &opt );
#ifdef PTW32_STATIC_LIB
pthread_win32_thread_detach_np();
pthread_win32_process_detach_np();
#endif
return ret;
}
BOOL WINAPI DllMain(HINSTANCE hinst_dll, DWORD reason, LPVOID reserved)
{
switch (reason) {
case DLL_PROCESS_ATTACH:
timeBeginPeriod(1);
#ifdef PTW32_STATIC_LIB
pthread_win32_process_attach_np();
#endif
break;
case DLL_PROCESS_DETACH:
timeEndPeriod(1);
#ifdef PTW32_STATIC_LIB
pthread_win32_process_detach_np();
#endif
break;
case DLL_THREAD_ATTACH:
#ifdef PTW32_STATIC_LIB
pthread_win32_thread_attach_np();
#endif
break;
case DLL_THREAD_DETACH:
#ifdef PTW32_STATIC_LIB
pthread_win32_thread_detach_np();
#endif
break;
}
UNUSED_PARAMETER(hinst_dll);
UNUSED_PARAMETER(reserved);
return true;
}
BOOL APIENTRY DllMain(HMODULE hm, DWORD why, LPVOID rsrv) {
WSADATA wsa;
switch (why) {
case DLL_PROCESS_ATTACH:
if(WSAStartup(MAKEWORD(2,2), &wsa))
return FALSE;
fix_paths();
return pthread_win32_process_attach_np();
break;
case DLL_THREAD_ATTACH:
return pthread_win32_thread_attach_np ();
break;
case DLL_THREAD_DETACH:
return pthread_win32_thread_detach_np ();
break;
case DLL_PROCESS_DETACH:
WSACleanup();
pthread_win32_thread_detach_np ();
return pthread_win32_process_detach_np ();
break;
}
}
void *Thread::ThreadRun(void *myThread)
{
Thread *thread = reinterpret_cast<Thread*>(myThread);
thread->mRunning = true;
#ifdef PTW32_STATIC_LIB
pthread_win32_thread_attach_np();
#endif
try {
thread->mTask->run();
}
catch(const std::exception &e)
{
LogWarn("Thread::ThreadRun", String("Unhandled exception in thread: ") + e.what());
}
catch(...)
{
LogWarn("Thread::ThreadRun", String("Unhandled unknown exception in thread"));
}
thread->mRunning = false;
if(thread->mAutoDelete) delete thread;
#ifdef PTW32_STATIC_LIB
pthread_win32_thread_detach_np();
#endif
pthread_exit(NULL);
return NULL;
}
/* Callback for our DLL so we can initialize pthread */
BOOL WINAPI DllMain( HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved )
{
#if PTW32_STATIC_LIB
switch( fdwReason )
{
case DLL_PROCESS_ATTACH:
pthread_win32_process_attach_np();
case DLL_THREAD_ATTACH:
pthread_win32_thread_attach_np();
break;
case DLL_THREAD_DETACH:
pthread_win32_thread_detach_np();
break;
case DLL_PROCESS_DETACH:
pthread_win32_thread_detach_np();
pthread_win32_process_detach_np();
break;
}
#endif
return TRUE;
}
static void _init(void) {
#ifdef WIN32
int iResult;
#endif
if (Initialized)
return;
#ifdef WIN32
pthread_win32_process_attach_np();
pthread_win32_thread_attach_np();
// Initialize Winsock
iResult = WSAStartup(MAKEWORD(2, 2), &wsaData);
if (iResult != 0) {
LOG_ERROR("WSAStartup failed: %d\n", iResult);
}
CoInitialize(NULL); // To initialize the COM library on the current thread
#endif
Initialized = 1;
ms_errno = 0;
} /* _init() */
void *Thread::ThreadCall(void *myWrapper)
{
Wrapper *wrapper = reinterpret_cast<Wrapper*>(myWrapper);
wrapper->thread->mRunning = true;
#ifdef PTW32_STATIC_LIB
pthread_win32_thread_attach_np();
#endif
try {
wrapper->call();
}
catch(const std::exception &e)
{
LogWarn("Thread::ThreadCall", String("Unhandled exception in thread: ") + e.what());
}
catch(...)
{
LogWarn("Thread::ThreadCall", String("Unhandled unknown exception in thread"));
}
delete wrapper;
wrapper->thread->mRunning = false;
#ifdef PTW32_STATIC_LIB
pthread_win32_thread_detach_np();
#endif
pthread_exit(NULL);
return NULL;
}
/*
* Dear c++: Please don't mangle this name. -thanks
*/
extern "C"
#endif /* __cplusplus */
BOOL WINAPI
DllMain (HINSTANCE hinstDll, DWORD fdwReason, LPVOID lpvReserved)
{
BOOL result = PTW32_TRUE;
switch (fdwReason)
{
case DLL_PROCESS_ATTACH:
result = pthread_win32_process_attach_np ();
break;
case DLL_THREAD_ATTACH:
/*
* A thread is being created
*/
result = pthread_win32_thread_attach_np ();
break;
case DLL_THREAD_DETACH:
/*
* A thread is exiting cleanly
*/
result = pthread_win32_thread_detach_np ();
break;
case DLL_PROCESS_DETACH:
(void) pthread_win32_thread_detach_np ();
result = pthread_win32_process_detach_np ();
break;
}
return (result);
} /* DllMain */
int main( int _argc, char * * _argv )
{
if( _argc < 3 )
{
fprintf( stderr, "not enough arguments\n" );
return -1;
}
#ifdef LMMS_BUILD_WIN32
// (non-portable) initialization of statically linked pthread library
pthread_win32_process_attach_np();
pthread_win32_thread_attach_np();
#endif
RemoteZynAddSubFx * remoteZASF =
new RemoteZynAddSubFx( atoi( _argv[1] ), atoi( _argv[2] ) );
remoteZASF->run();
delete remoteZASF;
#ifdef LMMS_BUILD_WIN32
pthread_win32_thread_detach_np();
pthread_win32_process_detach_np();
#endif
return 0;
}
/* Run non-portable pthread win32 startup */
void threadpool::win32_init()
{
#ifdef WIN32
static bool initialized = false;
if(initialized==false){
pthread_win32_process_attach_np();
pthread_win32_thread_attach_np();
initialized=true;
}
#endif
}
void* Thread::_internal_callback( void* itsme )
{
jASSUME( itsme != NULL );
pthread_win32_thread_attach_np();
Thread& owner = *((Thread*)itsme);
owner.m_returncode = owner.Callback();
owner.m_terminated = true;
pthread_win32_thread_detach_np();
return NULL;
}
LocalZynAddSubFx::LocalZynAddSubFx() :
m_master( NULL ),
m_ioEngine( NULL )
{
for( int i = 0; i < NumKeys; ++i )
{
m_runningNotes[i] = 0;
}
if( s_instanceCount == 0 )
{
#ifdef LMMS_BUILD_WIN32
#ifndef __WINPTHREADS_VERSION
// (non-portable) initialization of statically linked pthread library
pthread_win32_process_attach_np();
pthread_win32_thread_attach_np();
#endif
#endif
initConfig();
synth = new SYNTH_T;
synth->oscilsize = config.cfg.OscilSize;
synth->alias();
srand( time( NULL ) );
denormalkillbuf = new float[synth->buffersize];
for( int i = 0; i < synth->buffersize; ++i )
{
denormalkillbuf[i] = (RND-0.5)*1e-16;
}
}
++s_instanceCount;
m_ioEngine = new NulEngine;
m_master = new Master();
m_master->swaplr = 0;
}
//FILE* ff ;
int main_bak( int argc, char **argv )
{
x264_param_t param;
cli_opt_t opt;
int ret;
//ff = fopen("ff_org.264", "wb");
initDebugLog("debug_org.log");
DEBUG_LOG(INF, "main begin");
#ifdef PTW32_STATIC_LIB
pthread_win32_process_attach_np();
pthread_win32_thread_attach_np();
#endif
#ifdef _WIN32
_setmode(_fileno(stdin), _O_BINARY);
_setmode(_fileno(stdout), _O_BINARY);
#endif
/* 初始化输入参数结构体，设置为默认值 */
x264_param_default( ¶m );
/* 解析命令行，设置param(包括函数指针)，并保存到opt的文件中。打开输出的文件.Parse command line */
if( Parse( argc, argv, ¶m, &opt ) < 0 )
return -1;
/* 是否响应Ctrl+C终端。Control-C handler */
signal( SIGINT, SigIntHandler );
/* 编码主控函数,编码输入输出文件分别是opt中的hin和hout */
ret = Encode( ¶m, &opt );
#ifdef PTW32_STATIC_LIB
pthread_win32_thread_detach_np();
pthread_win32_process_detach_np();
#endif
DEBUG_LOG(INF, "main end");
return ret;
}
BOOL WINAPI DllMain(HINSTANCE hinst_dll, DWORD reason, LPVOID reserved)
{
switch (reason) {
case DLL_PROCESS_ATTACH:
pthread_win32_process_attach_np();
break;
case DLL_PROCESS_DETACH:
pthread_win32_process_detach_np();
break;
case DLL_THREAD_ATTACH:
pthread_win32_thread_attach_np();
break;
case DLL_THREAD_DETACH:
pthread_win32_thread_detach_np();
break;
}
return true;
}
/*****************************************************************************
* Open: probe the encoder
*****************************************************************************/
static int Open ( vlc_object_t *p_this )
{
encoder_t *p_enc = (encoder_t *)p_this;
encoder_sys_t *p_sys;
int i_val;
char *psz_val;
int i_qmin = 0, i_qmax = 0;
x264_nal_t *nal;
int i, i_nal;
if( p_enc->fmt_out.i_codec != VLC_CODEC_H264 &&
!p_enc->b_force )
{
return VLC_EGENERIC;
}
/* X264_POINTVER or X264_VERSION are not available */
msg_Dbg ( p_enc, "version x264 0.%d.X", X264_BUILD );
config_ChainParse( p_enc, SOUT_CFG_PREFIX, ppsz_sout_options, p_enc->p_cfg );
p_enc->fmt_out.i_cat = VIDEO_ES;
p_enc->fmt_out.i_codec = VLC_CODEC_H264;
p_enc->fmt_in.i_codec = VLC_CODEC_I420;
p_enc->pf_encode_video = Encode;
p_enc->pf_encode_audio = NULL;
p_enc->p_sys = p_sys = malloc( sizeof( encoder_sys_t ) );
if( !p_sys )
return VLC_ENOMEM;
p_sys->i_interpolated_dts = 0;
p_sys->psz_stat_name = NULL;
p_sys->p_buffer = NULL;
x264_param_default( &p_sys->param );
p_sys->param.i_width = p_enc->fmt_in.video.i_width;
p_sys->param.i_height = p_enc->fmt_in.video.i_height;
p_sys->param.rc.f_qcompress = var_GetFloat( p_enc, SOUT_CFG_PREFIX "qcomp" );
/* transcode-default bitrate is 0,
* set more to ABR if user specifies bitrate */
if( p_enc->fmt_out.i_bitrate > 0 )
{
p_sys->param.rc.i_bitrate = p_enc->fmt_out.i_bitrate / 1000;
p_sys->param.rc.i_rc_method = X264_RC_ABR;
}
else /* Set default to CRF */
{
i_val = var_GetInteger( p_enc, SOUT_CFG_PREFIX "crf" );
if( i_val > 0 && i_val <= 51 )
{
p_sys->param.rc.f_rf_constant = i_val;
p_sys->param.rc.i_rc_method = X264_RC_CRF;
}
}
i_val = var_GetInteger( p_enc, SOUT_CFG_PREFIX "qpstep" );
if( i_val >= 0 && i_val <= 51 ) p_sys->param.rc.i_qp_step = i_val;
i_val = var_GetInteger( p_enc, SOUT_CFG_PREFIX "qpmin" );
if( i_val >= 0 && i_val <= 51 )
{
i_qmin = i_val;
p_sys->param.rc.i_qp_min = i_qmin;
}
i_val = var_GetInteger( p_enc, SOUT_CFG_PREFIX "qpmax" );
if( i_val >= 0 && i_val <= 51 )
{
i_qmax = i_val;
p_sys->param.rc.i_qp_max = i_qmax;
}
i_val = var_GetInteger( p_enc, SOUT_CFG_PREFIX "qp" );
if( i_val >= 0 && i_val <= 51 )
{
if( i_qmin > i_val ) i_qmin = i_val;
if( i_qmax < i_val ) i_qmax = i_val;
/* User defined QP-value, so change ratecontrol method */
p_sys->param.rc.i_rc_method = X264_RC_CQP;
p_sys->param.rc.i_qp_constant = i_val;
p_sys->param.rc.i_qp_min = i_qmin;
p_sys->param.rc.i_qp_max = i_qmax;
}
p_sys->param.rc.f_rate_tolerance = var_GetFloat( p_enc,
SOUT_CFG_PREFIX "ratetol" );
p_sys->param.rc.f_vbv_buffer_init = var_GetFloat( p_enc,
SOUT_CFG_PREFIX "vbv-init" );
p_sys->param.rc.i_vbv_buffer_size = var_GetInteger( p_enc,
SOUT_CFG_PREFIX "vbv-bufsize" );
/* max bitrate = average bitrate -> CBR */
i_val = var_GetInteger( p_enc, SOUT_CFG_PREFIX "vbv-maxrate" );
if( !i_val && p_sys->param.rc.i_rc_method == X264_RC_ABR )
p_sys->param.rc.i_vbv_max_bitrate = p_sys->param.rc.i_bitrate;
else if ( i_val )
p_sys->param.rc.i_vbv_max_bitrate = i_val;
p_sys->param.b_cabac = var_GetBool( p_enc, SOUT_CFG_PREFIX "cabac" );
/* disable deblocking when nf (no loop filter) is enabled */
p_sys->param.b_deblocking_filter = !var_GetBool( p_enc, SOUT_CFG_PREFIX "nf" );
psz_val = var_GetString( p_enc, SOUT_CFG_PREFIX "deblock" );
if( psz_val )
{
char *p = strchr( psz_val, ':' );
p_sys->param.i_deblocking_filter_alphac0 = atoi( psz_val );
p_sys->param.i_deblocking_filter_beta = p ?
atoi( p+1 ) : p_sys->param.i_deblocking_filter_alphac0;
free( psz_val );
}
psz_val = var_GetString( p_enc, SOUT_CFG_PREFIX "psy-rd" );
if( psz_val )
{
char *p = strchr( psz_val, ':' );
p_sys->param.analyse.f_psy_rd = us_atof( psz_val );
p_sys->param.analyse.f_psy_trellis = p ? us_atof( p+1 ) : 0;
free( psz_val );
}
psz_val = var_GetString( p_enc, SOUT_CFG_PREFIX "level" );
if( psz_val )
{
if( us_atof (psz_val) < 6 )
p_sys->param.i_level_idc = (int) (10 * us_atof (psz_val)
+ .5);
else
p_sys->param.i_level_idc = atoi (psz_val);
free( psz_val );
}
p_sys->param.b_interlaced = var_GetBool( p_enc, SOUT_CFG_PREFIX "interlaced" );
p_sys->param.rc.f_ip_factor = var_GetFloat( p_enc, SOUT_CFG_PREFIX "ipratio" );
p_sys->param.rc.f_pb_factor = var_GetFloat( p_enc, SOUT_CFG_PREFIX "pbratio" );
p_sys->param.rc.f_complexity_blur = var_GetFloat( p_enc, SOUT_CFG_PREFIX "cplxblur" );
p_sys->param.rc.f_qblur = var_GetFloat( p_enc, SOUT_CFG_PREFIX "qblur" );
p_sys->param.rc.i_aq_mode = var_GetInteger( p_enc, SOUT_CFG_PREFIX "aq-mode" );
p_sys->param.rc.f_aq_strength = var_GetFloat( p_enc, SOUT_CFG_PREFIX "aq-strength" );
if( var_GetBool( p_enc, SOUT_CFG_PREFIX "verbose" ) )
p_sys->param.i_log_level = X264_LOG_DEBUG;
if( var_GetBool( p_enc, SOUT_CFG_PREFIX "quiet" ) )
p_sys->param.i_log_level = X264_LOG_NONE;
i_val = var_GetInteger( p_enc, SOUT_CFG_PREFIX "sps-id" );
if( i_val >= 0 ) p_sys->param.i_sps_id = i_val;
if( var_GetBool( p_enc, SOUT_CFG_PREFIX "aud" ) )
p_sys->param.b_aud = true;
i_val = var_GetInteger( p_enc, SOUT_CFG_PREFIX "keyint" );
if( i_val > 0 ) p_sys->param.i_keyint_max = i_val;
i_val = var_GetInteger( p_enc, SOUT_CFG_PREFIX "min-keyint" );
if( i_val > 0 ) p_sys->param.i_keyint_min = i_val;
i_val = var_GetInteger( p_enc, SOUT_CFG_PREFIX "bframes" );
if( i_val >= 0 && i_val <= 16 )
p_sys->param.i_bframe = i_val;
#if X264_BUILD >= 78
psz_val = var_GetString( p_enc, SOUT_CFG_PREFIX "bpyramid" );
p_sys->param.i_bframe_pyramid = X264_B_PYRAMID_NONE;
if( !strcmp( psz_val, "none" ) )
{
p_sys->param.i_bframe_pyramid = X264_B_PYRAMID_NONE;
} else if ( !strcmp( psz_val, "strict" ) )
{
p_sys->param.i_bframe_pyramid = X264_B_PYRAMID_STRICT;
} else if ( !strcmp( psz_val, "normal" ) )
{
p_sys->param.i_bframe_pyramid = X264_B_PYRAMID_NORMAL;
}
free( psz_val );
#else
p_sys->param.b_bframe_pyramid = var_GetBool( p_enc, SOUT_CFG_PREFIX "bpyramid" );
#endif
i_val = var_GetInteger( p_enc, SOUT_CFG_PREFIX "ref" );
if( i_val > 0 && i_val <= 15 )
p_sys->param.i_frame_reference = i_val;
i_val = var_GetInteger( p_enc, SOUT_CFG_PREFIX "scenecut" );
if( i_val >= -1 && i_val <= 100 )
p_sys->param.i_scenecut_threshold = i_val;
p_sys->param.b_deterministic = var_GetBool( p_enc,
SOUT_CFG_PREFIX "non-deterministic" );
i_val = var_GetInteger( p_enc, SOUT_CFG_PREFIX "subme" );
if( i_val >= 1 && i_val <= SUBME_MAX )
p_sys->param.analyse.i_subpel_refine = i_val;
//TODO: psz_val == NULL ?
psz_val = var_GetString( p_enc, SOUT_CFG_PREFIX "me" );
if( !strcmp( psz_val, "dia" ) )
{
p_sys->param.analyse.i_me_method = X264_ME_DIA;
}
else if( !strcmp( psz_val, "hex" ) )
{
p_sys->param.analyse.i_me_method = X264_ME_HEX;
}
else if( !strcmp( psz_val, "umh" ) )
{
p_sys->param.analyse.i_me_method = X264_ME_UMH;
}
else if( !strcmp( psz_val, "esa" ) )
{
p_sys->param.analyse.i_me_method = X264_ME_ESA;
}
else if( !strcmp( psz_val, "tesa" ) )
{
p_sys->param.analyse.i_me_method = X264_ME_TESA;
}
free( psz_val );
i_val = var_GetInteger( p_enc, SOUT_CFG_PREFIX "merange" );
if( i_val >= 0 && i_val <= 64 )
p_sys->param.analyse.i_me_range = i_val;
p_sys->param.analyse.i_mv_range = var_GetInteger( p_enc,
SOUT_CFG_PREFIX "mvrange" );
p_sys->param.analyse.i_mv_range_thread = var_GetInteger( p_enc,
SOUT_CFG_PREFIX "mvrange-thread" );
psz_val = var_GetString( p_enc, SOUT_CFG_PREFIX "direct" );
if( !strcmp( psz_val, "none" ) )
{
p_sys->param.analyse.i_direct_mv_pred = X264_DIRECT_PRED_NONE;
}
else if( !strcmp( psz_val, "spatial" ) )
{
p_sys->param.analyse.i_direct_mv_pred = X264_DIRECT_PRED_SPATIAL;
}
else if( !strcmp( psz_val, "temporal" ) )
{
p_sys->param.analyse.i_direct_mv_pred = X264_DIRECT_PRED_TEMPORAL;
}
else if( !strcmp( psz_val, "auto" ) )
{
p_sys->param.analyse.i_direct_mv_pred = X264_DIRECT_PRED_AUTO;
}
free( psz_val );
p_sys->param.analyse.b_psnr = var_GetBool( p_enc, SOUT_CFG_PREFIX "psnr" );
p_sys->param.analyse.b_ssim = var_GetBool( p_enc, SOUT_CFG_PREFIX "ssim" );
p_sys->param.analyse.b_weighted_bipred = var_GetBool( p_enc,
SOUT_CFG_PREFIX "weightb" );
p_sys->param.i_bframe_adaptive = var_GetInteger( p_enc,
SOUT_CFG_PREFIX "b-adapt" );
i_val = var_GetInteger( p_enc, SOUT_CFG_PREFIX "b-bias" );
if( i_val >= -100 && i_val <= 100 )
p_sys->param.i_bframe_bias = i_val;
p_sys->param.analyse.b_chroma_me = var_GetBool( p_enc,
SOUT_CFG_PREFIX "chroma-me" );
p_sys->param.analyse.i_chroma_qp_offset = var_GetInteger( p_enc,
SOUT_CFG_PREFIX "chroma-qp-offset" );
p_sys->param.analyse.b_mixed_references = var_GetBool( p_enc,
SOUT_CFG_PREFIX "mixed-refs" );
i_val = var_GetInteger( p_enc, SOUT_CFG_PREFIX "trellis" );
if( i_val >= 0 && i_val <= 2 )
p_sys->param.analyse.i_trellis = i_val;
p_sys->param.analyse.b_fast_pskip = var_GetBool( p_enc,
SOUT_CFG_PREFIX "fast-pskip" );
i_val = var_GetInteger( p_enc, SOUT_CFG_PREFIX "nr" );
if( i_val >= 0 && i_val <= 1000 )
p_sys->param.analyse.i_noise_reduction = i_val;
p_sys->param.analyse.b_dct_decimate = var_GetBool( p_enc,
SOUT_CFG_PREFIX "dct-decimate" );
i_val = var_GetInteger( p_enc, SOUT_CFG_PREFIX "deadzone-inter" );
if( i_val >= 0 && i_val <= 32 )
p_sys->param.analyse.i_luma_deadzone[0] = i_val;
i_val = var_GetInteger( p_enc, SOUT_CFG_PREFIX "deadzone-intra" );
if( i_val >= 0 && i_val <= 32 )
p_sys->param.analyse.i_luma_deadzone[1] = i_val;
if( !var_GetBool( p_enc, SOUT_CFG_PREFIX "asm" ) )
p_sys->param.cpu = 0;
#ifndef X264_ANALYSE_BSUB16x16
# define X264_ANALYSE_BSUB16x16 0
#endif
psz_val = var_GetString( p_enc, SOUT_CFG_PREFIX "partitions" );
if( !strcmp( psz_val, "none" ) )
{
p_sys->param.analyse.inter = 0;
}
else if( !strcmp( psz_val, "fast" ) )
{
p_sys->param.analyse.inter = X264_ANALYSE_I4x4;
}
else if( !strcmp( psz_val, "normal" ) )
{
p_sys->param.analyse.inter =
X264_ANALYSE_I4x4 |
X264_ANALYSE_PSUB16x16;
#ifdef X264_ANALYSE_I8x8
p_sys->param.analyse.inter |= X264_ANALYSE_I8x8;
#endif
}
else if( !strcmp( psz_val, "slow" ) )
{
p_sys->param.analyse.inter =
X264_ANALYSE_I4x4 |
X264_ANALYSE_PSUB16x16 |
X264_ANALYSE_BSUB16x16;
#ifdef X264_ANALYSE_I8x8
p_sys->param.analyse.inter |= X264_ANALYSE_I8x8;
#endif
}
else if( !strcmp( psz_val, "all" ) )
{
p_sys->param.analyse.inter = ~0;
}
free( psz_val );
p_sys->param.analyse.b_transform_8x8 = var_GetBool( p_enc,
SOUT_CFG_PREFIX "8x8dct" );
if( p_enc->fmt_in.video.i_aspect > 0 )
{
int64_t i_num, i_den;
unsigned int i_dst_num, i_dst_den;
i_num = p_enc->fmt_in.video.i_aspect *
(int64_t)p_enc->fmt_in.video.i_height;
i_den = VOUT_ASPECT_FACTOR * p_enc->fmt_in.video.i_width;
vlc_ureduce( &i_dst_num, &i_dst_den, i_num, i_den, 0 );
p_sys->param.vui.i_sar_width = i_dst_num;
p_sys->param.vui.i_sar_height = i_dst_den;
}
if( p_enc->fmt_in.video.i_frame_rate_base > 0 )
{
p_sys->param.i_fps_num = p_enc->fmt_in.video.i_frame_rate;
p_sys->param.i_fps_den = p_enc->fmt_in.video.i_frame_rate_base;
}
/* x264 vbv-bufsize = 0 (default). if not provided set period
in seconds for local maximum bitrate (cache/bufsize) based
on average bitrate when use has told bitrate.
vbv-buffer size is set to bitrate * secods between keyframes */
if( !p_sys->param.rc.i_vbv_buffer_size &&
p_sys->param.rc.i_rc_method == X264_RC_ABR &&
p_sys->param.i_fps_num )
{
p_sys->param.rc.i_vbv_buffer_size = p_sys->param.rc.i_bitrate *
p_sys->param.i_fps_den;
p_sys->param.rc.i_vbv_buffer_size *= p_sys->param.i_keyint_max;
p_sys->param.rc.i_vbv_buffer_size /= p_sys->param.i_fps_num;
}
/* Check if user has given some profile (baseline,main,high) to limit
* settings, and apply those*/
psz_val = var_GetString( p_enc, SOUT_CFG_PREFIX "profile" );
if( psz_val )
{
if( !strcasecmp( psz_val, "baseline" ) )
{
msg_Dbg( p_enc, "Limiting to baseline profile");
p_sys->param.analyse.b_transform_8x8 = 0;
p_sys->param.b_cabac = 0;
p_sys->param.i_bframe = 0;
}
else if (!strcasecmp( psz_val, "main" ) )
{
msg_Dbg( p_enc, "Limiting to main-profile");
p_sys->param.analyse.b_transform_8x8 = 0;
}
/* high profile don't restrict stuff*/
}
free( psz_val );
unsigned i_cpu = vlc_CPU();
if( !(i_cpu & CPU_CAPABILITY_MMX) )
{
p_sys->param.cpu &= ~X264_CPU_MMX;
}
if( !(i_cpu & CPU_CAPABILITY_MMXEXT) )
{
p_sys->param.cpu &= ~X264_CPU_MMXEXT;
}
if( !(i_cpu & CPU_CAPABILITY_SSE) )
{
p_sys->param.cpu &= ~X264_CPU_SSE;
}
if( !(i_cpu & CPU_CAPABILITY_SSE2) )
{
p_sys->param.cpu &= ~X264_CPU_SSE2;
}
/* BUILD 29 adds support for multi-threaded encoding while BUILD 49 (r543)
also adds support for threads = 0 for automatically selecting an optimal
value (cores * 1.5) based on detected CPUs. Default behavior for x264 is
threads = 1, however VLC usage differs and uses threads = 0 (auto) by
default unless ofcourse transcode threads is explicitly specified.. */
p_sys->param.i_threads = p_enc->i_threads;
psz_val = var_GetString( p_enc, SOUT_CFG_PREFIX "stats" );
if( psz_val )
{
p_sys->param.rc.psz_stat_in =
p_sys->param.rc.psz_stat_out =
p_sys->psz_stat_name = psz_val;
}
i_val = var_GetInteger( p_enc, SOUT_CFG_PREFIX "pass" );
if( i_val > 0 && i_val <= 3 )
{
p_sys->param.rc.b_stat_write = i_val & 1;
p_sys->param.rc.b_stat_read = i_val & 2;
}
/* We need to initialize pthreadw32 before we open the encoder,
but only once for the whole application. Since pthreadw32
doesn't keep a refcount, do it ourselves. */
#ifdef PTW32_STATIC_LIB
vlc_value_t lock, count;
var_Create( p_enc->p_libvlc, "pthread_win32_mutex", VLC_VAR_MUTEX );
var_Get( p_enc->p_libvlc, "pthread_win32_mutex", &lock );
vlc_mutex_lock( lock.p_address );
var_Create( p_enc->p_libvlc, "pthread_win32_count", VLC_VAR_INTEGER );
var_Get( p_enc->p_libvlc, "pthread_win32_count", &count );
if( count.i_int == 0 )
{
msg_Dbg( p_enc, "initializing pthread-win32" );
if( !pthread_win32_process_attach_np() || !pthread_win32_thread_attach_np() )
{
msg_Warn( p_enc, "pthread Win32 Initialization failed" );
vlc_mutex_unlock( lock.p_address );
return VLC_EGENERIC;
}
}
count.i_int++;
var_Set( p_enc->p_libvlc, "pthread_win32_count", count );
vlc_mutex_unlock( lock.p_address );
#endif
/* Set lookahead value to lower than default,
* as rtp-output without mux doesn't handle
* difference that well yet*/
p_sys->param.rc.i_lookahead=5;
/* Open the encoder */
p_sys->h = x264_encoder_open( &p_sys->param );
if( p_sys->h == NULL )
{
msg_Err( p_enc, "cannot open x264 encoder" );
Close( VLC_OBJECT(p_enc) );
return VLC_EGENERIC;
}
/* alloc mem */
p_sys->i_buffer = 4 * p_enc->fmt_in.video.i_width *
p_enc->fmt_in.video.i_height + 1000;
p_sys->p_buffer = malloc( p_sys->i_buffer );
if( !p_sys->p_buffer )
{
Close( VLC_OBJECT(p_enc) );
return VLC_ENOMEM;
}
/* get the globals headers */
p_enc->fmt_out.i_extra = 0;
p_enc->fmt_out.p_extra = NULL;
p_enc->fmt_out.i_extra = x264_encoder_headers( p_sys->h, &nal, &i_nal );
p_enc->fmt_out.p_extra = malloc( p_enc->fmt_out.i_extra );
if( !p_enc->fmt_out.p_extra )
{
Close( VLC_OBJECT(p_enc) );
return VLC_ENOMEM;
}
void *p_tmp = p_enc->fmt_out.p_extra;
for( i = 0; i < i_nal; i++ )
{
memcpy( p_tmp, nal[i].p_payload, nal[i].i_payload );
p_tmp += nal[i].i_payload;
}
return VLC_SUCCESS;
}
/**
* From the pthreads readme for mingw:
* Define PTW32_STATIC_LIB when building your application. Also, your
* application must call a two non-portable routines to initialise the
* some state on startup and cleanup before exit. One other routine needs
* to be called to cleanup after any Win32 threads have called POSIX API
* routines. See README.NONPORTABLE or the html reference manual pages for
* details on these routines:
*
* BOOL pthread_win32_process_attach_np (void);
* BOOL pthread_win32_process_detach_np (void);
* BOOL pthread_win32_thread_attach_np (void); // Currently a no-op
* BOOL pthread_win32_thread_detach_np (void);
*
*/
void threadpool::win32_init()
{
pthread_win32_process_attach_np();
pthread_win32_thread_attach_np();
}
/****************************************************************************
* Function: WorkerThread
*
* Description:
* Implements a thread pool worker.
* Worker waits for a job to become available.
* Worker picks up persistent jobs first, high priority, med priority,
* then low priority.
* If worker remains idle for more than specified max, the worker
* is released.
* Internal Only.
* Parameters:
* void * arg -> is cast to ThreadPool *
*****************************************************************************/
static void *WorkerThread( void *arg )
{
time_t start = 0;
ThreadPoolJob *job = NULL;
ListNode *head = NULL;
struct timespec timeout;
int retCode = 0;
int persistent = -1;
ThreadPool *tp = ( ThreadPool *) arg;
// allow static linking
#ifdef WIN32
#ifdef PTW32_STATIC_LIB
pthread_win32_thread_attach_np();
#endif
#endif
assert( tp != NULL );
// Increment total thread count
ithread_mutex_lock( &tp->mutex );
tp->totalThreads++;
ithread_cond_broadcast( &tp->start_and_shutdown );
ithread_mutex_unlock( &tp->mutex );
SetSeed();
StatsTime( &start );
while( 1 ) {
ithread_mutex_lock( &tp->mutex );
if( job ) {
FreeThreadPoolJob( tp, job );
job = NULL;
}
retCode = 0;
tp->stats.idleThreads++;
tp->stats.totalWorkTime += ( StatsTime( NULL ) - start ); // work time
StatsTime( &start ); // idle time
if( persistent == 1 ) {
// Persistent thread
// becomes a regular thread
tp->persistentThreads--;
}
if( persistent == 0 ) {
tp->stats.workerThreads--;
}
// Check for a job or shutdown
while( tp->lowJobQ.size == 0 &&
tp->medJobQ.size == 0 &&
tp->highJobQ.size == 0 &&
!tp->persistentJob &&
!tp->shutdown ) {
// If wait timed out
// and we currently have more than the
// min threads, or if we have more than the max threads
// (only possible if the attributes have been reset)
// let this thread die.
if( ( retCode == ETIMEDOUT &&
tp->totalThreads > tp->attr.minThreads ) ||
( tp->attr.maxThreads != -1 &&
tp->totalThreads > tp->attr.maxThreads ) ) {
tp->stats.idleThreads--;
tp->totalThreads--;
ithread_cond_broadcast( &tp->start_and_shutdown );
ithread_mutex_unlock( &tp->mutex );
#ifdef WIN32
#ifdef PTW32_STATIC_LIB
// allow static linking
pthread_win32_thread_detach_np ();
#endif
#endif
return NULL;
}
SetRelTimeout( &timeout, tp->attr.maxIdleTime );
// wait for a job up to the specified max time
retCode = ithread_cond_timedwait(
&tp->condition, &tp->mutex, &timeout );
}
tp->stats.idleThreads--;
tp->stats.totalIdleTime += ( StatsTime( NULL ) - start ); // idle time
StatsTime( &start ); // work time
// bump priority of starved jobs
BumpPriority( tp );
// if shutdown then stop
if( tp->shutdown ) {
tp->totalThreads--;
ithread_cond_broadcast( &tp->start_and_shutdown );
ithread_mutex_unlock( &tp->mutex );
#ifdef WIN32
#ifdef PTW32_STATIC_LIB
// allow static linking
pthread_win32_thread_detach_np ();
#endif
#endif
return NULL;
} else {
// Pick up persistent job if available
if( tp->persistentJob ) {
job = tp->persistentJob;
tp->persistentJob = NULL;
tp->persistentThreads++;
persistent = 1;
ithread_cond_broadcast( &tp->start_and_shutdown );
} else {
tp->stats.workerThreads++;
persistent = 0;
// Pick the highest priority job
if( tp->highJobQ.size > 0 ) {
head = ListHead( &tp->highJobQ );
job = ( ThreadPoolJob *) head->item;
CalcWaitTime( tp, HIGH_PRIORITY, job );
ListDelNode( &tp->highJobQ, head, 0 );
} else if( tp->medJobQ.size > 0 ) {
head = ListHead( &tp->medJobQ );
job = ( ThreadPoolJob *) head->item;
CalcWaitTime( tp, MED_PRIORITY, job );
ListDelNode( &tp->medJobQ, head, 0 );
} else if( tp->lowJobQ.size > 0 ) {
head = ListHead( &tp->lowJobQ );
job = ( ThreadPoolJob *) head->item;
CalcWaitTime( tp, LOW_PRIORITY, job );
ListDelNode( &tp->lowJobQ, head, 0 );
} else {
// Should never get here
assert( 0 );
tp->stats.workerThreads--;
tp->totalThreads--;
ithread_cond_broadcast( &tp->start_and_shutdown );
ithread_mutex_unlock( &tp->mutex );
return NULL;
}
}
}
ithread_mutex_unlock( &tp->mutex );
if( SetPriority( job->priority ) != 0 ) {
// In the future can log
// info
} else {
// In the future can log
// info
}
// run the job
job->func( job->arg );
// return to Normal
SetPriority( DEFAULT_PRIORITY );
}
}
int main(int argc, char* argv[])
{
char *albumdir = 0, *musicfilename, *file_path = 0;
int i, area_idx;
sacd_reader_t *sacd_reader;
#ifdef PTW32_STATIC_LIB
pthread_win32_process_attach_np();
pthread_win32_thread_attach_np();
#endif
init();
if (parse_options(argc, argv))
{
setlocale(LC_ALL, "");
if (fwide(stdout, 1) < 0)
{
fprintf(stderr, "ERROR: Output not set to wide.\n");
}
// default to 2 channel
if (opts.two_channel == 0 && opts.multi_channel == 0)
{
opts.two_channel = 1;
}
sacd_reader = sacd_open(opts.input_device);
if (sacd_reader)
{
handle = scarletbook_open(sacd_reader, 0);
if (handle)
{
if (opts.print)
{
scarletbook_print(handle);
}
if (opts.output_dsf || opts.output_iso || opts.output_dsdiff || opts.output_dsdiff_em || opts.export_cue_sheet)
{
output = scarletbook_output_create(handle, handle_status_update_track_callback, handle_status_update_progress_callback, safe_fwprintf);
// select the channel area
area_idx = ((has_multi_channel(handle) && opts.multi_channel) || !has_two_channel(handle)) ? handle->mulch_area_idx : handle->twoch_area_idx;
albumdir = (strlen(opts.output_file) > 0 ? strdup(opts.output_file) : get_album_dir(handle));
if (opts.output_iso)
{
uint32_t total_sectors = sacd_get_total_sectors(sacd_reader);
#ifdef SECTOR_LIMIT
#define FAT32_SECTOR_LIMIT 2090000
uint32_t sector_size = FAT32_SECTOR_LIMIT;
uint32_t sector_offset = 0;
if (total_sectors > FAT32_SECTOR_LIMIT)
{
musicfilename = (char *) malloc(512);
file_path = make_filename(0, 0, albumdir, "iso");
for (i = 1; total_sectors != 0; i++)
{
sector_size = min(total_sectors, FAT32_SECTOR_LIMIT);
snprintf(musicfilename, 512, "%s.%03d", file_path, i);
scarletbook_output_enqueue_raw_sectors(output, sector_offset, sector_size, musicfilename, "iso");
sector_offset += sector_size;
total_sectors -= sector_size;
}
free(musicfilename);
}
else
#endif
{
get_unique_filename(&albumdir, "iso");
file_path = make_filename(0, 0, albumdir, "iso");
scarletbook_output_enqueue_raw_sectors(output, 0, total_sectors, file_path, "iso");
}
}
else if (opts.output_dsdiff_em)
{
get_unique_filename(&albumdir, "dff");
file_path = make_filename(0, 0, albumdir, "dff");
scarletbook_output_enqueue_track(output, area_idx, 0, file_path, "dsdiff_edit_master",
(opts.convert_dst ? 1 : handle->area[area_idx].area_toc->frame_format != FRAME_FORMAT_DST));
}
else if (opts.output_dsf || opts.output_dsdiff)
{
// create the output folder
get_unique_dir(0, &albumdir);
recursive_mkdir(albumdir, 0774);
// fill the queue with items to rip
for (i = 0; i < handle->area[area_idx].area_toc->track_count; i++)
{
if (opts.select_tracks && opts.selected_tracks[i] == 0)
continue;
musicfilename = get_music_filename(handle, area_idx, i, opts.output_file);
if (opts.output_dsf)
{
file_path = make_filename(0, albumdir, musicfilename, "dsf");
scarletbook_output_enqueue_track(output, area_idx, i, file_path, "dsf",
1 /* always decode to DSD */);
}
else if (opts.output_dsdiff)
{
file_path = make_filename(0, albumdir, musicfilename, "dff");
scarletbook_output_enqueue_track(output, area_idx, i, file_path, "dsdiff",
(opts.convert_dst ? 1 : handle->area[area_idx].area_toc->frame_format != FRAME_FORMAT_DST));
}
free(musicfilename);
free(file_path);
file_path = 0;
}
}
if (opts.export_cue_sheet)
{
char *cue_file_path = make_filename(0, 0, albumdir, "cue");
#ifdef _WIN32
wchar_t *wide_filename = (wchar_t *) charset_convert(cue_file_path, strlen(cue_file_path), "UTF-8", sizeof(wchar_t) == 2 ? "UCS-2-INTERNAL" : "UCS-4-INTERNAL");
#else
wchar_t *wide_filename = (wchar_t *) charset_convert(cue_file_path, strlen(cue_file_path), "UTF-8", "WCHAR_T");
#endif
fwprintf(stdout, L"Exporting CUE sheet [%ls]\n", wide_filename);
if (!file_path)
file_path = make_filename(0, 0, albumdir, "dff");
write_cue_sheet(handle, file_path, area_idx, cue_file_path);
free(cue_file_path);
free(wide_filename);
}
free(file_path);
started_processing = time(0);
scarletbook_output_start(output);
scarletbook_output_destroy(output);
fprintf(stdout, "\rWe are done.. \n");
}
scarletbook_close(handle);
free(albumdir);
}
}
sacd_close(sacd_reader);
#ifndef _WIN32
freopen(0, "w", stdout);
#endif
if (fwide(stdout, -1) >= 0)
{
fprintf(stderr, "ERROR: Output not set to byte oriented.\n");
}
}
free_lock(g_fwprintf_lock);
destroy_logging();
#ifdef PTW32_STATIC_LIB
pthread_win32_process_detach_np();
pthread_win32_thread_detach_np();
#endif
printf("\n");
return 0;
}
void avcodec_register_all(void)
{
static int initialized;
if (initialized)
return;
initialized = 1;
/* hardware accelerators */
REGISTER_HWACCEL (H263_VAAPI, h263_vaapi);
REGISTER_HWACCEL (H264_DXVA2, h264_dxva2);
REGISTER_HWACCEL (H264_VAAPI, h264_vaapi);
REGISTER_HWACCEL (MPEG1_VDPAU, mpeg1_vdpau);
REGISTER_HWACCEL (MPEG2_DXVA2, mpeg2_dxva2);
REGISTER_HWACCEL (MPEG2_VAAPI, mpeg2_vaapi);
REGISTER_HWACCEL (MPEG2_VDPAU, mpeg2_vdpau);
REGISTER_HWACCEL (MPEG4_VAAPI, mpeg4_vaapi);
REGISTER_HWACCEL (VC1_DXVA2, vc1_dxva2);
REGISTER_HWACCEL (VC1_VAAPI, vc1_vaapi);
REGISTER_HWACCEL (WMV3_DXVA2, wmv3_dxva2);
REGISTER_HWACCEL (WMV3_VAAPI, wmv3_vaapi);
#ifdef PTW32_STATIC_LIB
pthread_win32_process_attach_np();
pthread_win32_thread_attach_np();
atexit(detach_ptw32);
#endif
#ifdef PTW32_STATIC_LIB
pthread_win32_process_attach_np();
pthread_win32_thread_attach_np();
atexit(detach_ptw32);
#endif
/* video codecs */
REGISTER_ENCODER (A64MULTI, a64multi);
REGISTER_ENCODER (A64MULTI5, a64multi5);
REGISTER_DECODER (AASC, aasc);
REGISTER_DECODER (AMV, amv);
REGISTER_DECODER (ANM, anm);
REGISTER_DECODER (ANSI, ansi);
REGISTER_ENCDEC (ASV1, asv1);
REGISTER_ENCDEC (ASV2, asv2);
REGISTER_DECODER (AURA, aura);
REGISTER_DECODER (AURA2, aura2);
REGISTER_DECODER (AVS, avs);
REGISTER_DECODER (BETHSOFTVID, bethsoftvid);
REGISTER_DECODER (BFI, bfi);
REGISTER_DECODER (BINK, bink);
REGISTER_ENCDEC (BMP, bmp);
REGISTER_DECODER (C93, c93);
REGISTER_DECODER (CAVS, cavs);
REGISTER_DECODER (CDGRAPHICS, cdgraphics);
REGISTER_DECODER (CINEPAK, cinepak);
REGISTER_DECODER (CLJR, cljr);
REGISTER_DECODER (CSCD, cscd);
REGISTER_DECODER (CYUV, cyuv);
REGISTER_DECODER (DFA, dfa);
REGISTER_ENCDEC (DNXHD, dnxhd);
REGISTER_ENCDEC (DPX, dpx);
REGISTER_DECODER (DSICINVIDEO, dsicinvideo);
REGISTER_ENCDEC (DVVIDEO, dvvideo);
REGISTER_DECODER (DXA, dxa);
REGISTER_DECODER (EACMV, eacmv);
REGISTER_DECODER (EAMAD, eamad);
REGISTER_DECODER (EATGQ, eatgq);
REGISTER_DECODER (EATGV, eatgv);
REGISTER_DECODER (EATQI, eatqi);
REGISTER_DECODER (EIGHTBPS, eightbps);
REGISTER_DECODER (EIGHTSVX_EXP, eightsvx_exp);
REGISTER_DECODER (EIGHTSVX_FIB, eightsvx_fib);
REGISTER_DECODER (ESCAPE124, escape124);
REGISTER_ENCDEC (FFV1, ffv1);
REGISTER_ENCDEC (FFVHUFF, ffvhuff);
REGISTER_ENCDEC (FLASHSV, flashsv);
REGISTER_DECODER (FLIC, flic);
REGISTER_ENCDEC (FLV, flv);
REGISTER_DECODER (FOURXM, fourxm);
REGISTER_DECODER (FRAPS, fraps);
REGISTER_DECODER (FRWU, frwu);
REGISTER_ENCDEC (GIF, gif);
REGISTER_ENCDEC (H261, h261);
REGISTER_ENCDEC (H263, h263);
REGISTER_DECODER (H263I, h263i);
REGISTER_ENCODER (H263P, h263p);
REGISTER_DECODER (H264, h264);
REGISTER_DECODER (H264_CRYSTALHD, h264_crystalhd);
REGISTER_DECODER (H264_VDPAU, h264_vdpau);
REGISTER_ENCDEC (HUFFYUV, huffyuv);
REGISTER_DECODER (IDCIN, idcin);
REGISTER_DECODER (IFF_BYTERUN1, iff_byterun1);
REGISTER_DECODER (IFF_ILBM, iff_ilbm);
REGISTER_DECODER (INDEO2, indeo2);
REGISTER_DECODER (INDEO3, indeo3);
REGISTER_DECODER (INDEO5, indeo5);
REGISTER_DECODER (INTERPLAY_VIDEO, interplay_video);
REGISTER_ENCDEC (JPEGLS, jpegls);
REGISTER_DECODER (JV, jv);
REGISTER_DECODER (KGV1, kgv1);
REGISTER_DECODER (KMVC, kmvc);
REGISTER_DECODER (LAGARITH, lagarith);
REGISTER_ENCODER (LJPEG, ljpeg);
REGISTER_DECODER (LOCO, loco);
REGISTER_DECODER (MDEC, mdec);
REGISTER_DECODER (MIMIC, mimic);
REGISTER_ENCDEC (MJPEG, mjpeg);
REGISTER_DECODER (MJPEGB, mjpegb);
REGISTER_DECODER (MMVIDEO, mmvideo);
REGISTER_DECODER (MOTIONPIXELS, motionpixels);
REGISTER_DECODER (MPEG_XVMC, mpeg_xvmc);
REGISTER_ENCDEC (MPEG1VIDEO, mpeg1video);
REGISTER_ENCDEC (MPEG2VIDEO, mpeg2video);
REGISTER_ENCDEC (MPEG4, mpeg4);
REGISTER_DECODER (MPEG4_CRYSTALHD, mpeg4_crystalhd);
REGISTER_DECODER (MPEG4_VDPAU, mpeg4_vdpau);
REGISTER_DECODER (MPEGVIDEO, mpegvideo);
REGISTER_DECODER (MPEG_VDPAU, mpeg_vdpau);
REGISTER_DECODER (MPEG1_VDPAU, mpeg1_vdpau);
REGISTER_DECODER (MPEG2_CRYSTALHD, mpeg2_crystalhd);
REGISTER_DECODER (MSMPEG4_CRYSTALHD, msmpeg4_crystalhd);
REGISTER_ENCDEC (MSMPEG4V1, msmpeg4v1);
REGISTER_ENCDEC (MSMPEG4V2, msmpeg4v2);
REGISTER_ENCDEC (MSMPEG4V3, msmpeg4v3);
REGISTER_DECODER (MSRLE, msrle);
REGISTER_DECODER (MSVIDEO1, msvideo1);
REGISTER_DECODER (MSZH, mszh);
REGISTER_DECODER (NUV, nuv);
REGISTER_ENCDEC (PAM, pam);
REGISTER_ENCDEC (PBM, pbm);
REGISTER_ENCDEC (PCX, pcx);
REGISTER_ENCDEC (PGM, pgm);
REGISTER_ENCDEC (PGMYUV, pgmyuv);
REGISTER_DECODER (PICTOR, pictor);
REGISTER_ENCDEC (PNG, png);
REGISTER_ENCDEC (PPM, ppm);
REGISTER_DECODER (PTX, ptx);
REGISTER_DECODER (QDRAW, qdraw);
REGISTER_DECODER (QPEG, qpeg);
REGISTER_ENCDEC (QTRLE, qtrle);
REGISTER_DECODER (R10K, r10k);
REGISTER_DECODER (R210, r210);
REGISTER_ENCDEC (RAWVIDEO, rawvideo);
REGISTER_DECODER (RL2, rl2);
REGISTER_ENCDEC (ROQ, roq);
REGISTER_DECODER (RPZA, rpza);
REGISTER_ENCDEC (RV10, rv10);
REGISTER_ENCDEC (RV20, rv20);
REGISTER_DECODER (RV30, rv30);
REGISTER_DECODER (RV40, rv40);
REGISTER_ENCDEC (SGI, sgi);
REGISTER_DECODER (SMACKER, smacker);
REGISTER_DECODER (SMC, smc);
REGISTER_ENCDEC (SNOW, snow);
REGISTER_DECODER (SP5X, sp5x);
REGISTER_DECODER (SUNRAST, sunrast);
REGISTER_ENCDEC (SVQ1, svq1);
REGISTER_DECODER (SVQ3, svq3);
REGISTER_ENCDEC (TARGA, targa);
REGISTER_DECODER (THEORA, theora);
REGISTER_DECODER (THP, thp);
REGISTER_DECODER (TIERTEXSEQVIDEO, tiertexseqvideo);
REGISTER_ENCDEC (TIFF, tiff);
REGISTER_DECODER (TMV, tmv);
REGISTER_DECODER (TRUEMOTION1, truemotion1);
REGISTER_DECODER (TRUEMOTION2, truemotion2);
REGISTER_DECODER (TSCC, tscc);
REGISTER_DECODER (TXD, txd);
REGISTER_DECODER (ULTI, ulti);
REGISTER_ENCDEC (V210, v210);
REGISTER_DECODER (V210X, v210x);
REGISTER_DECODER (VB, vb);
REGISTER_DECODER (VC1, vc1);
REGISTER_DECODER (VC1_CRYSTALHD, vc1_crystalhd);
REGISTER_DECODER (VC1_VDPAU, vc1_vdpau);
REGISTER_DECODER (VCR1, vcr1);
REGISTER_DECODER (VMDVIDEO, vmdvideo);
REGISTER_DECODER (VMNC, vmnc);
REGISTER_DECODER (VP3, vp3);
REGISTER_DECODER (VP5, vp5);
REGISTER_DECODER (VP6, vp6);
REGISTER_DECODER (VP6A, vp6a);
REGISTER_DECODER (VP6F, vp6f);
REGISTER_DECODER (VP8, vp8);
REGISTER_DECODER (VQA, vqa);
REGISTER_ENCDEC (WMV1, wmv1);
REGISTER_ENCDEC (WMV2, wmv2);
REGISTER_DECODER (WMV3, wmv3);
REGISTER_DECODER (WMV3_CRYSTALHD, wmv3_crystalhd);
REGISTER_DECODER (WMV3_VDPAU, wmv3_vdpau);
REGISTER_DECODER (WNV1, wnv1);
REGISTER_DECODER (XAN_WC3, xan_wc3);
REGISTER_DECODER (XAN_WC4, xan_wc4);
REGISTER_DECODER (XL, xl);
REGISTER_DECODER (YOP, yop);
REGISTER_ENCDEC (ZLIB, zlib);
REGISTER_ENCDEC (ZMBV, zmbv);
/* audio codecs */
REGISTER_ENCDEC (AAC, aac);
REGISTER_DECODER (AAC_LATM, aac_latm);
REGISTER_ENCDEC (AC3, ac3);
REGISTER_ENCODER (AC3_FIXED, ac3_fixed); //deprecated, just for libav compatibility
// REGISTER_ENCODER (AC3_FLOAT, ac3_float); dont remove dont outcomment, for configure
REGISTER_ENCDEC (ALAC, alac);
REGISTER_DECODER (ALS, als);
REGISTER_DECODER (AMRNB, amrnb);
REGISTER_DECODER (AMRWB, amrwb);
REGISTER_DECODER (APE, ape);
REGISTER_DECODER (ATRAC1, atrac1);
REGISTER_DECODER (ATRAC3, atrac3);
REGISTER_DECODER (BINKAUDIO_DCT, binkaudio_dct);
REGISTER_DECODER (BINKAUDIO_RDFT, binkaudio_rdft);
REGISTER_DECODER (COOK, cook);
REGISTER_DECODER (DCA, dca);
REGISTER_DECODER (DSICINAUDIO, dsicinaudio);
REGISTER_DECODER (EAC3, eac3);
REGISTER_ENCDEC (FLAC, flac);
REGISTER_DECODER (GSM, gsm);
REGISTER_DECODER (GSM_MS, gsm_ms);
REGISTER_DECODER (IMC, imc);
REGISTER_DECODER (MACE3, mace3);
REGISTER_DECODER (MACE6, mace6);
REGISTER_DECODER (MLP, mlp);
REGISTER_DECODER (MP1, mp1);
REGISTER_DECODER (MP1FLOAT, mp1float);
REGISTER_ENCDEC (MP2, mp2);
REGISTER_DECODER (MP2FLOAT, mp2float);
REGISTER_DECODER (MP3, mp3);
REGISTER_DECODER (MP3FLOAT, mp3float);
REGISTER_DECODER (MP3ADU, mp3adu);
REGISTER_DECODER (MP3ADUFLOAT, mp3adufloat);
REGISTER_DECODER (MP3ON4, mp3on4);
REGISTER_DECODER (MP3ON4FLOAT, mp3on4float);
REGISTER_DECODER (MPC7, mpc7);
REGISTER_DECODER (MPC8, mpc8);
REGISTER_ENCDEC (NELLYMOSER, nellymoser);
REGISTER_DECODER (QCELP, qcelp);
REGISTER_DECODER (QDM2, qdm2);
REGISTER_ENCDEC (RA_144, ra_144);
REGISTER_DECODER (RA_288, ra_288);
REGISTER_DECODER (SHORTEN, shorten);
REGISTER_DECODER (SIPR, sipr);
REGISTER_DECODER (SMACKAUD, smackaud);
REGISTER_ENCDEC (SONIC, sonic);
REGISTER_ENCODER (SONIC_LS, sonic_ls);
REGISTER_DECODER (TRUEHD, truehd);
REGISTER_DECODER (TRUESPEECH, truespeech);
REGISTER_DECODER (TTA, tta);
REGISTER_DECODER (TWINVQ, twinvq);
REGISTER_DECODER (VMDAUDIO, vmdaudio);
REGISTER_ENCDEC (VORBIS, vorbis);
REGISTER_DECODER (WAVPACK, wavpack);
REGISTER_DECODER (WMAPRO, wmapro);
REGISTER_ENCDEC (WMAV1, wmav1);
REGISTER_ENCDEC (WMAV2, wmav2);
REGISTER_DECODER (WMAVOICE, wmavoice);
REGISTER_DECODER (WS_SND1, ws_snd1);
/* PCM codecs */
REGISTER_ENCDEC (PCM_ALAW, pcm_alaw);
REGISTER_DECODER (PCM_BLURAY, pcm_bluray);
REGISTER_DECODER (PCM_DVD, pcm_dvd);
REGISTER_ENCDEC (PCM_F32BE, pcm_f32be);
REGISTER_ENCDEC (PCM_F32LE, pcm_f32le);
REGISTER_ENCDEC (PCM_F64BE, pcm_f64be);
REGISTER_ENCDEC (PCM_F64LE, pcm_f64le);
REGISTER_DECODER (PCM_LXF, pcm_lxf);
REGISTER_ENCDEC (PCM_MULAW, pcm_mulaw);
REGISTER_ENCDEC (PCM_S8, pcm_s8);
REGISTER_ENCDEC (PCM_S16BE, pcm_s16be);
REGISTER_ENCDEC (PCM_S16LE, pcm_s16le);
REGISTER_DECODER (PCM_S16LE_PLANAR, pcm_s16le_planar);
REGISTER_ENCDEC (PCM_S24BE, pcm_s24be);
REGISTER_ENCDEC (PCM_S24DAUD, pcm_s24daud);
REGISTER_ENCDEC (PCM_S24LE, pcm_s24le);
REGISTER_ENCDEC (PCM_S32BE, pcm_s32be);
REGISTER_ENCDEC (PCM_S32LE, pcm_s32le);
REGISTER_ENCDEC (PCM_U8, pcm_u8);
REGISTER_ENCDEC (PCM_U16BE, pcm_u16be);
REGISTER_ENCDEC (PCM_U16LE, pcm_u16le);
REGISTER_ENCDEC (PCM_U24BE, pcm_u24be);
REGISTER_ENCDEC (PCM_U24LE, pcm_u24le);
REGISTER_ENCDEC (PCM_U32BE, pcm_u32be);
REGISTER_ENCDEC (PCM_U32LE, pcm_u32le);
REGISTER_ENCDEC (PCM_ZORK , pcm_zork);
/* DPCM codecs */
REGISTER_DECODER (INTERPLAY_DPCM, interplay_dpcm);
REGISTER_ENCDEC (ROQ_DPCM, roq_dpcm);
REGISTER_DECODER (SOL_DPCM, sol_dpcm);
REGISTER_DECODER (XAN_DPCM, xan_dpcm);
/* ADPCM codecs */
REGISTER_DECODER (ADPCM_4XM, adpcm_4xm);
REGISTER_ENCDEC (ADPCM_ADX, adpcm_adx);
REGISTER_DECODER (ADPCM_CT, adpcm_ct);
REGISTER_DECODER (ADPCM_EA, adpcm_ea);
REGISTER_DECODER (ADPCM_EA_MAXIS_XA, adpcm_ea_maxis_xa);
REGISTER_DECODER (ADPCM_EA_R1, adpcm_ea_r1);
REGISTER_DECODER (ADPCM_EA_R2, adpcm_ea_r2);
REGISTER_DECODER (ADPCM_EA_R3, adpcm_ea_r3);
REGISTER_DECODER (ADPCM_EA_XAS, adpcm_ea_xas);
REGISTER_ENCDEC (ADPCM_G722, adpcm_g722);
REGISTER_ENCDEC (ADPCM_G726, adpcm_g726);
REGISTER_DECODER (ADPCM_IMA_AMV, adpcm_ima_amv);
REGISTER_DECODER (ADPCM_IMA_DK3, adpcm_ima_dk3);
REGISTER_DECODER (ADPCM_IMA_DK4, adpcm_ima_dk4);
REGISTER_DECODER (ADPCM_IMA_EA_EACS, adpcm_ima_ea_eacs);
REGISTER_DECODER (ADPCM_IMA_EA_SEAD, adpcm_ima_ea_sead);
REGISTER_DECODER (ADPCM_IMA_ISS, adpcm_ima_iss);
REGISTER_ENCDEC (ADPCM_IMA_QT, adpcm_ima_qt);
REGISTER_DECODER (ADPCM_IMA_SMJPEG, adpcm_ima_smjpeg);
REGISTER_ENCDEC (ADPCM_IMA_WAV, adpcm_ima_wav);
REGISTER_DECODER (ADPCM_IMA_WS, adpcm_ima_ws);
REGISTER_ENCDEC (ADPCM_MS, adpcm_ms);
REGISTER_DECODER (ADPCM_SBPRO_2, adpcm_sbpro_2);
REGISTER_DECODER (ADPCM_SBPRO_3, adpcm_sbpro_3);
REGISTER_DECODER (ADPCM_SBPRO_4, adpcm_sbpro_4);
REGISTER_ENCDEC (ADPCM_SWF, adpcm_swf);
REGISTER_DECODER (ADPCM_THP, adpcm_thp);
REGISTER_DECODER (ADPCM_XA, adpcm_xa);
REGISTER_ENCDEC (ADPCM_YAMAHA, adpcm_yamaha);
/* subtitles */
REGISTER_ENCDEC (ASS, ass);
REGISTER_ENCDEC (DVBSUB, dvbsub);
REGISTER_ENCDEC (DVDSUB, dvdsub);
REGISTER_DECODER (PGSSUB, pgssub);
REGISTER_ENCDEC (SRT, srt);
REGISTER_ENCDEC (XSUB, xsub);
/* external libraries */
REGISTER_DECODER (LIBCELT, libcelt);
REGISTER_ENCDEC (LIBDIRAC, libdirac);
REGISTER_ENCODER (LIBFAAC, libfaac);
REGISTER_ENCDEC (LIBGSM, libgsm);
REGISTER_ENCDEC (LIBGSM_MS, libgsm_ms);
REGISTER_ENCODER (LIBMP3LAME, libmp3lame);
REGISTER_ENCDEC (LIBOPENCORE_AMRNB, libopencore_amrnb);
REGISTER_DECODER (LIBOPENCORE_AMRWB, libopencore_amrwb);
REGISTER_DECODER (LIBOPENJPEG, libopenjpeg);
REGISTER_ENCDEC (LIBSCHROEDINGER, libschroedinger);
REGISTER_DECODER (LIBSPEEX, libspeex);
REGISTER_ENCODER (LIBTHEORA, libtheora);
REGISTER_ENCODER (LIBVO_AACENC, libvo_aacenc);
REGISTER_ENCODER (LIBVO_AMRWBENC, libvo_amrwbenc);
REGISTER_ENCODER (LIBVORBIS, libvorbis);
REGISTER_ENCDEC (LIBVPX, libvpx);
REGISTER_ENCODER (LIBX264, libx264);
REGISTER_ENCODER (LIBXAVS, libxavs);
REGISTER_ENCODER (LIBXVID, libxvid);
/* parsers */
REGISTER_PARSER (AAC, aac);
REGISTER_PARSER (AAC_LATM, aac_latm);
REGISTER_PARSER (AC3, ac3);
REGISTER_PARSER (CAVSVIDEO, cavsvideo);
REGISTER_PARSER (DCA, dca);
REGISTER_PARSER (DIRAC, dirac);
REGISTER_PARSER (DNXHD, dnxhd);
REGISTER_PARSER (DVBSUB, dvbsub);
REGISTER_PARSER (DVDSUB, dvdsub);
REGISTER_PARSER (FLAC, flac);
REGISTER_PARSER (H261, h261);
REGISTER_PARSER (H263, h263);
REGISTER_PARSER (H264, h264);
REGISTER_PARSER (MJPEG, mjpeg);
REGISTER_PARSER (MLP, mlp);
REGISTER_PARSER (MPEG4VIDEO, mpeg4video);
REGISTER_PARSER (MPEGAUDIO, mpegaudio);
REGISTER_PARSER (MPEGVIDEO, mpegvideo);
REGISTER_PARSER (PNM, pnm);
REGISTER_PARSER (VC1, vc1);
REGISTER_PARSER (VP3, vp3);
REGISTER_PARSER (VP8, vp8);
/* bitstream filters */
REGISTER_BSF (AAC_ADTSTOASC, aac_adtstoasc);
REGISTER_BSF (CHOMP, chomp);
REGISTER_BSF (DUMP_EXTRADATA, dump_extradata);
REGISTER_BSF (H264_MP4TOANNEXB, h264_mp4toannexb);
REGISTER_BSF (IMX_DUMP_HEADER, imx_dump_header);
REGISTER_BSF (MJPEG2JPEG, mjpeg2jpeg);
REGISTER_BSF (MJPEGA_DUMP_HEADER, mjpega_dump_header);
REGISTER_BSF (MP3_HEADER_COMPRESS, mp3_header_compress);
REGISTER_BSF (MP3_HEADER_DECOMPRESS, mp3_header_decompress);
REGISTER_BSF (MOV2TEXTSUB, mov2textsub);
REGISTER_BSF (NOISE, noise);
REGISTER_BSF (REMOVE_EXTRADATA, remove_extradata);
REGISTER_BSF (TEXT2MOVSUB, text2movsub);
}
