int preferences::set(options option, const int val){
int l,r;
char buf[1024];
int v = val;
// check type of option
if( opt_defs[option].type != INT ){
fprintf(stderr,"preferences::set(%s,int) called for type %d\n",
opt_defs[option].name,opt_defs[option].type);
}
// check range
if( sscanf(opt_defs[option].minimum,"%d",&l) != 1){
fprintf(stderr,"error reading opt_defs[option].minimum\n");
return RC_FAILED;
}
if( sscanf(opt_defs[option].maximum,"%d",&r) != 1){
fprintf(stderr,"error reading opt_defs[option].maximum\n");
return RC_FAILED;
}
if( v < l ){
fprintf(stderr,"%s : value < min : %d < %d\n", opt_defs[option].name, v, l);
v = l;
fprintf(stderr," using %d as value instead.\n", v);
}
if( v > r ){
fprintf(stderr,"%s : value > max : %d > %d\n", opt_defs[option].name, v, r);
v = r;
fprintf(stderr," using %d as value instead.\n", v);
}
// set value
if( opt_defs[option].current_val )
ADM_dealloc(opt_defs[option].current_val);
snprintf(buf,1024,"%d",v);
buf[1023] = '\0';
opt_defs[option].current_val = ADM_strdup(buf);
if( ! opt_defs[option].current_val )
return RC_FAILED;
return RC_OK;
}
void
FileOutputStream::Write( uint8_t *buf, unsigned int len )
{
uint8_t *p = buf;
unsigned int plen = len;
int rc;
ADM_assert(strm_fd != -1);
while( (rc=write(strm_fd,p,plen)) != plen ){
if( rc > 0 ){
p+=rc;
plen-=rc;
continue;
}
if( rc == -1 && (errno == ENOSPC
#ifndef __MINGW32__
|| errno == EDQUOT
#endif
) ){
char msg[512];
fprintf(stderr,"slaveThread: we have a problem. errno=%u\n",errno);
ADM_assert(snprintf(msg,512,"can't write to file \"%s\": %s\n%s\n",
cur_filename,
(errno==ENOSPC?"filesystem full":"quota exceeded"),
"Please free up some space and press RETRY to try again.")!=-1);
mutex_slaveThread_problem.lock();
kind_of_slaveThread_problem = ADM_strdup(msg);
cond_slaveThread_problem->wait(); /* implicit mutex_slaveThread_problem.unlock(); */
ADM_dealloc(kind_of_slaveThread_problem);
kind_of_slaveThread_problem = NULL;
if( kind_of_slaveThread_problem_rc == 0 ){ /* ignore */
/* it doesn't make any sense to continue */
mjpeg_error_exit1( "Failed write: %s", cur_filename );
}
}else{
mjpeg_error_exit1( "Failed write: %s", cur_filename );
}
}
}
uint8_t asfHeader::open(char *name)
{
_fd=fopen(name,"rb");
if(!_fd)
{
GUI_Error_HIG("File Error.","Cannot open file\n");
return 0;
}
myName=ADM_strdup(name);
if(!getHeaders())
{
return 0;
}
buildIndex();
fseeko(_fd,_dataStartOffset,SEEK_SET);
_packet=new asfPacket(_fd,_nbPackets,_packetSize,&readQueue,_dataStartOffset);
curSeq=1;
if(_nbAudioTrack)
{
_curAudio=new asfAudio(this,_currentAudioStream);
}
return 1;
}
/**
\fn GUI_FileSelWrite (const char *label, char **name, uint32_t access)
\brief Ask for a file for reading (access=0) or writing (access=1)
*/
static void GUI_FileSelSelectReadInternal(const char *label, const char *ext, char **name)
{
*name = NULL;
QString str ;
QString fileName,dot=QString(".");
QString filterFile=QString(QT_TRANSLATE_NOOP("qfile","All files (*.*)"));
bool doFilter = !!(ext && strlen(ext));
QFileDialog::Options opts;
//printf("Do filer=%d\n",(int)doFilter);
std::string lastFolder;
admCoreUtils::getLastReadFolder(lastFolder);
if (lastFolder.size())
{
str = QFileInfo(QString::fromUtf8(lastFolder.c_str())).path();
/* LASTDIR may have gone; then do nothing and use current dir instead (implied) */
if (!QDir(str).exists())
str.clear();
}
if(doFilter)
{
filterFile=QString(ext)+QString(QT_TRANSLATE_NOOP("qfile"," files (*."))+QString(ext)+QString(");;")+filterFile;
}
fileName = QFileDialog::getOpenFileName(NULL,
label, // caption
str, // folder
filterFile, // filter
NULL, // selected filter
opts);
if (fileName.isNull() ) return;
*name=ADM_strdup(fileName.toUtf8().constData());
admCoreUtils::setLastReadFolder(std::string(fileName.toUtf8().constData()));
}
JSBool ADM_JSAvidemuxVideo::AddFilter(JSContext *cx, JSObject *obj, uintN argc,
jsval *argv, jsval *rval)
{// begin AddFilter
VF_FILTERS filter;
// default return value
*rval = BOOLEAN_TO_JSVAL(false);
if(argc == 0)
return JS_FALSE;
filter = filterGetTagFromName(JS_GetStringBytes(JSVAL_TO_STRING(argv[0])));
printf("Adding Filter \"%d\"... \n",filter);
Arg args[argc];
char *v;
for(int i=0;i<argc;i++)
{
args[i].type=APM_STRING;
if(JSVAL_IS_STRING(argv[i]) == false)
{
return JS_FALSE;
}
v=ADM_strdup(JS_GetStringBytes(JSVAL_TO_STRING(argv[i])));
args[i].arg.string=v;
}
enterLock();
*rval= BOOLEAN_TO_JSVAL(filterAddScript(filter,argc,args));
leaveLock();
for(int i=0;i<argc;i++)
{
ADM_dealloc(args[i].arg.string);
}
return JS_TRUE;
}// end AddFilter
/**
\fn DIA_Preferences
\brief Handle preference dialog
*/
uint8_t DIA_Preferences(void)
{
uint32_t olddevice,newdevice;
bool use_odml=0;
uint32_t autosplit=0;
uint32_t render;
bool useTray=0;
bool useSwap=0;
uint32_t lavcThreads=0;
uint32_t encodePriority=2;
uint32_t indexPriority=2;
uint32_t playbackPriority=0;
uint32_t downmix;
bool mpeg_no_limit=0;
uint32_t msglevel=2;
uint32_t mixer=0;
char *alsaDevice=NULL;
bool balternate_mp3_tag=true;
uint32_t pp_type=3;
uint32_t pp_value=5;
bool bvdpau=false;
bool hzd,vzd,dring;
bool capsMMX,capsMMXEXT,caps3DNOW,caps3DNOWEXT,capsSSE,capsSSE2,capsSSE3,capsSSSE3,capsAll;
bool hasOpenGl=false;
bool askPortAvisynth=false;
uint32_t defaultPortAvisynth = 9999;
#ifdef USE_OPENGL
prefs->get(FEATURES_ENABLE_OPENGL,&hasOpenGl);
#endif
olddevice=newdevice=AVDM_getCurrentDevice();
// Default pp
if(!prefs->get(DEFAULT_POSTPROC_TYPE,&pp_type)) pp_type=3;
if(!prefs->get(DEFAULT_POSTPROC_VALUE,&pp_value)) pp_value=3;
#define DOME(x,y) y=!!(pp_type & x)
DOME(1,hzd);
DOME(2,vzd);
DOME(4,dring);
// Cpu caps
#define CPU_CAPS(x) if(CpuCaps::myCpuMask & ADM_CPUCAP_##x) caps##x=1; else caps##x=0;
if(CpuCaps::myCpuMask==ADM_CPUCAP_ALL) capsAll=1; else capsAll=0;
CPU_CAPS(MMX);
CPU_CAPS(MMXEXT);
CPU_CAPS(3DNOW);
CPU_CAPS(3DNOWEXT);
CPU_CAPS(SSE);
CPU_CAPS(SSE2);
CPU_CAPS(SSE3);
CPU_CAPS(SSSE3);
//Avisynth
if(!prefs->get(AVISYNTH_AVISYNTH_ALWAYS_ASK, &askPortAvisynth))
{
ADM_info("Always ask not set\n");
askPortAvisynth=0;
}
if(!prefs->get(AVISYNTH_AVISYNTH_DEFAULTPORT, &defaultPortAvisynth))
{
printf("Port not set\n");
defaultPortAvisynth=9999;
}
ADM_info("Avisynth port: %d\n",defaultPortAvisynth);
// Alsa
#ifdef ALSA_SUPPORT
if( prefs->get(DEVICE_AUDIO_ALSA_DEVICE, &alsaDevice) != RC_OK )
alsaDevice = ADM_strdup("plughw:0,0");
#endif
// vdpau
prefs->get(FEATURES_VDPAU,&bvdpau);
// Alternate mp3 tag (haali)
prefs->get(FEATURES_ALTERNATE_MP3_TAG,&balternate_mp3_tag);
// Video renderer
if(prefs->get(VIDEODEVICE,&render)!=RC_OK)
{
render=(uint32_t)RENDER_GTK;
}
// SysTray
if(!prefs->get(FEATURES_USE_SYSTRAY,&useTray))
useTray=0;
// Accept mpeg for DVD when fq!=48 kHz
if(!prefs->get(FEATURES_MPEG_NO_LIMIT,&mpeg_no_limit)) mpeg_no_limit=0;
// Multithreads
prefs->get(FEATURES_THREADING_LAVC, &lavcThreads);
// Encoding priority
if(!prefs->get(PRIORITY_ENCODING, &encodePriority))
encodePriority=2;
// Indexing / unpacking priority
if(!prefs->get(PRIORITY_INDEXING, &indexPriority))
indexPriority=2;
// Playback priority
if(!prefs->get(PRIORITY_PLAYBACK, &playbackPriority))
playbackPriority=0;
// VCD/SVCD split point
if(!prefs->get(MPEGSPLIT_AUTOSPLIT, &autosplit))
autosplit=690;
// Open DML (Gmv)
if(!prefs->get(FEATURES_USE_ODML, &use_odml))
use_odml=0;
#if defined(ALSA_SUPPORT) || defined (OSS_SUPPORT)
// Master or PCM for audio
if(!prefs->get(FEATURES_AUDIOBAR_USES_MASTER, &useMaster))
useMaster=0;
#endif
// SWAP A&B if A>B
if(!prefs->get(FEATURES_SWAP_IF_A_GREATER_THAN_B, &useSwap))
useSwap=0;
// Get level of message verbosity
prefs->get(MESSAGE_LEVEL,&msglevel);
// Downmix default
if(prefs->get(DEFAULT_DOWNMIXING,&downmix)!=RC_OK)
{
downmix=0;
}
olddevice=newdevice=AVDM_getCurrentDevice();
// Audio device
/************************ Build diaelems ****************************************/
diaElemToggle useVdpau(&bvdpau,QT_TR_NOOP("Decode video using VDPAU"));
diaElemToggle useOpenGl(&hasOpenGl,QT_TR_NOOP("Enable openGl support"));
#ifndef USE_OPENGL
//useOpenGl.enable(0);
#endif
diaElemToggle useSysTray(&useTray,QT_TR_NOOP("_Use systray while encoding"));
diaElemToggle allowAnyMpeg(&mpeg_no_limit,QT_TR_NOOP("_Accept non-standard audio frequency for DVD"));
diaElemToggle openDml(&use_odml,QT_TR_NOOP("Create _OpenDML files"));
diaElemFrame frameSimd(QT_TR_NOOP("SIMD"));
diaElemToggle capsToggleAll(&capsAll,QT_TR_NOOP("Enable all SIMD"));
diaElemToggle capsToggleMMX(&capsMMX, QT_TR_NOOP("Enable MMX"));
diaElemToggle capsToggleMMXEXT(&capsMMXEXT, QT_TR_NOOP("Enable MMXEXT"));
diaElemToggle capsToggle3DNOW(&caps3DNOW, QT_TR_NOOP("Enable 3DNOW"));
diaElemToggle capsToggle3DNOWEXT(&caps3DNOWEXT, QT_TR_NOOP("Enable 3DNOWEXT"));
diaElemToggle capsToggleSSE(&capsSSE, QT_TR_NOOP("Enable SSE"));
diaElemToggle capsToggleSSE2(&capsSSE2, QT_TR_NOOP("Enable SSE2"));
diaElemToggle capsToggleSSE3(&capsSSE3, QT_TR_NOOP("Enable SSE3"));
diaElemToggle capsToggleSSSE3(&capsSSSE3, QT_TR_NOOP("Enable SSSE3"));
capsToggleAll.link(0, &capsToggleMMX);
capsToggleAll.link(0, &capsToggleMMXEXT);
capsToggleAll.link(0, &capsToggle3DNOW);
capsToggleAll.link(0, &capsToggle3DNOWEXT);
capsToggleAll.link(0, &capsToggleSSE);
capsToggleAll.link(0, &capsToggleSSE2);
capsToggleAll.link(0, &capsToggleSSE3);
capsToggleAll.link(0, &capsToggleSSSE3);
frameSimd.swallow(&capsToggleAll);
frameSimd.swallow(&capsToggleMMX);
frameSimd.swallow(&capsToggleMMXEXT);
frameSimd.swallow(&capsToggle3DNOW);
frameSimd.swallow(&capsToggle3DNOWEXT);
frameSimd.swallow(&capsToggleSSE);
frameSimd.swallow(&capsToggleSSE2);
frameSimd.swallow(&capsToggleSSE3);
frameSimd.swallow(&capsToggleSSSE3);
diaElemThreadCount lavcThreadCount(&lavcThreads, QT_TR_NOOP("_lavc threads:"));
diaElemFrame frameThread(QT_TR_NOOP("Multi-threading"));
frameThread.swallow(&lavcThreadCount);
diaMenuEntry priorityEntries[] = {
{0, QT_TR_NOOP("High"),NULL}
,{1, QT_TR_NOOP("Above normal"),NULL}
,{2, QT_TR_NOOP("Normal"),NULL}
,{3, QT_TR_NOOP("Below normal"),NULL}
,{4, QT_TR_NOOP("Low"),NULL}
};
diaElemMenu menuEncodePriority(&encodePriority,QT_TR_NOOP("_Encoding priority:"), sizeof(priorityEntries)/sizeof(diaMenuEntry), priorityEntries,"");
diaElemMenu menuIndexPriority(&indexPriority,QT_TR_NOOP("_Indexing/unpacking priority:"), sizeof(priorityEntries)/sizeof(diaMenuEntry), priorityEntries,"");
diaElemMenu menuPlaybackPriority(&playbackPriority,QT_TR_NOOP("_Playback priority:"), sizeof(priorityEntries)/sizeof(diaMenuEntry), priorityEntries,"");
diaElemFrame framePriority(QT_TR_NOOP("Prioritisation"));
framePriority.swallow(&menuEncodePriority);
framePriority.swallow(&menuIndexPriority);
framePriority.swallow(&menuPlaybackPriority);
diaElemUInteger autoSplit(&autosplit,QT_TR_NOOP("_Split MPEG files every (MB):"),10,4096);
diaElemToggle togTagMp3(&balternate_mp3_tag,QT_TR_NOOP("_Use alternative tag for MP3 in .mp4"));
diaMenuEntry videoMode[]={
{RENDER_GTK, getNativeRendererDesc(), NULL}
#ifdef USE_XV
,{RENDER_XV, QT_TR_NOOP("XVideo (best)"),NULL}
#endif
#ifdef USE_VDPAU
,{RENDER_VDPAU, QT_TR_NOOP("VDPAU (best)"),NULL}
#endif
#ifdef USE_OPENGL
,{RENDER_QTOPENGL, QT_TR_NOOP("OpenGL (best)"),NULL}
#endif
#ifdef USE_SDL
#ifdef _WIN32
,{RENDER_SDL, QT_TR_NOOP("MS Windows GDI (SDL)"),NULL}
,{RENDER_DIRECTX, QT_TR_NOOP("MS Windows DirectX (SDL)"),NULL}
#else
,{RENDER_SDL, QT_TR_NOOP("SDL (good)"),NULL}
#endif
#endif
};
diaElemMenu menuVideoMode(&render,QT_TR_NOOP("Video _display:"), sizeof(videoMode)/sizeof(diaMenuEntry),videoMode,"");
diaMenuEntry msgEntries[]={
{0, QT_TR_NOOP("No alerts"),NULL}
,{1, QT_TR_NOOP("Display only error alerts"),NULL}
,{2, QT_TR_NOOP("Display all alerts"),NULL}
};
diaElemMenu menuMessage(&msglevel,QT_TR_NOOP("_Message level:"), sizeof(msgEntries)/sizeof(diaMenuEntry),msgEntries,"");
#if defined(ALSA_SUPPORT) || defined (OSS_SUPPORT)
diaMenuEntry volumeEntries[]={
{0, QT_TR_NOOP("PCM"),NULL}
,{1, QT_TR_NOOP("Master"),NULL}};
diaElemMenu menuVolume(&useMaster,QT_TR_NOOP("_Volume control:"), sizeof(volumeEntries)/sizeof(diaMenuEntry),volumeEntries,"");
#endif
diaMenuEntry mixerEntries[]={
{0, QT_TR_NOOP("No downmixing"),NULL}
,{1, QT_TR_NOOP("Stereo"),NULL}
,{2, QT_TR_NOOP("Pro Logic"),NULL}
,{3, QT_TR_NOOP("Pro Logic II"),NULL}
};
diaElemMenu menuMixer(&downmix,QT_TR_NOOP("_Local playback downmixing:"), sizeof(mixerEntries)/sizeof(diaMenuEntry),mixerEntries,"");
//*********** AV_
//***AV
uint32_t nbAudioDevice=ADM_av_getNbDevices();
diaMenuEntryDynamic **audioDeviceItems=new diaMenuEntryDynamic *[nbAudioDevice+1];
audioDeviceItems[0]=new diaMenuEntryDynamic(0,"Dummy","Dummy");
for(int i=0;i<nbAudioDevice;i++)
{
const char *name;
uint32_t major,minor,patch;
ADM_av_getDeviceInfo(i, &name, &major,&minor,&patch);
audioDeviceItems[i+1]=new diaMenuEntryDynamic(i+1,name,name);
}
diaElemMenuDynamic menuAudio(&newdevice,QT_TR_NOOP("_AudioDevice"), nbAudioDevice+1,
audioDeviceItems,NULL);
// default Post proc
diaElemToggle fhzd(&hzd,QT_TR_NOOP("_Horizontal deblocking"));
diaElemToggle fvzd(&vzd,QT_TR_NOOP("_Vertical deblocking"));
diaElemToggle fdring(&dring,QT_TR_NOOP("De_ringing"));
diaElemUInteger postProcStrength(&pp_value,QT_TR_NOOP("_Strength:"),0,5);
diaElemFrame framePP(QT_TR_NOOP("Default Postprocessing"));
framePP.swallow(&fhzd);
framePP.swallow(&fvzd);
framePP.swallow(&fdring);
framePP.swallow(&postProcStrength);
/* User Interface */
diaElem *diaUser[]={&useSysTray,&menuMessage};
diaElemTabs tabUser(QT_TR_NOOP("User Interface"),2,diaUser);
/* Automation */
/* Output */
diaElem *diaOutput[]={&autoSplit,&openDml,&allowAnyMpeg,&togTagMp3};
diaElemTabs tabOutput(QT_TR_NOOP("Output"),4,(diaElem **)diaOutput);
/* Audio */
#if 0 //defined(ALSA_SUPPORT)
diaElem *diaAudio[]={&menuMixer,&menuVolume,&menuAudio,&entryAlsaDevice};
diaElemTabs tabAudio(QT_TR_NOOP("Audio"),4,(diaElem **)diaAudio);
//#elif defined(OSS_SUPPORT)
diaElem *diaAudio[]={&menuMixer,&menuVolume,&menuAudio};
diaElemTabs tabAudio(QT_TR_NOOP("Audio"),3,(diaElem **)diaAudio);
#endif
#if 1
diaElem *diaAudio[]={&menuMixer,&menuAudio};
diaElemTabs tabAudio(QT_TR_NOOP("Audio"),2,(diaElem **)diaAudio);
#endif
/* Video */
diaElem *diaVideo[]={&menuVideoMode,&framePP,&useVdpau,&useOpenGl};
diaElemTabs tabVideo(QT_TR_NOOP("Video"),4,(diaElem **)diaVideo);
/* CPU tab */
diaElem *diaCpu[]={&frameSimd};
diaElemTabs tabCpu(QT_TR_NOOP("CPU"),1,(diaElem **)diaCpu);
/* Threading tab */
diaElem *diaThreading[]={&frameThread, &framePriority};
diaElemTabs tabThreading(QT_TR_NOOP("Threading"),2,(diaElem **)diaThreading);
/* Avisynth tab */
diaElemToggle togAskAvisynthPort(&askPortAvisynth,"_Always ask which port to use");
diaElemUInteger uintDefaultPortAvisynth(&defaultPortAvisynth,"Default port to use",1024,65535);
diaElem *diaAvisynth[]={&togAskAvisynthPort, &uintDefaultPortAvisynth};
diaElemTabs tabAvisynth("Avisynth",2,(diaElem **)diaAvisynth);
/* Global Glyph tab */
// SET
diaElemTabs *tabs[]={&tabUser,&tabOutput,&tabAudio,&tabVideo,&tabCpu,&tabThreading, &tabAvisynth};
if( diaFactoryRunTabs(QT_TR_NOOP("Preferences"),7,tabs))
{
//
#ifdef USE_OPENGL
prefs->set(FEATURES_ENABLE_OPENGL,hasOpenGl);
#endif
// cpu caps
if(capsAll)
{
CpuCaps::myCpuMask=ADM_CPUCAP_ALL;
}else
{
CpuCaps::myCpuMask=0;
#undef CPU_CAPS
#define CPU_CAPS(x) if(caps##x) CpuCaps::myCpuMask|= ADM_CPUCAP_##x;
CPU_CAPS(MMX);
CPU_CAPS(MMXEXT);
CPU_CAPS(3DNOW);
CPU_CAPS(3DNOWEXT);
CPU_CAPS(SSE);
CPU_CAPS(SSE2);
CPU_CAPS(SSE3);
CPU_CAPS(SSSE3);
}
prefs->set(FEATURES_CPU_CAPS,CpuCaps::myCpuMask);
// Postproc
#undef DOME
#define DOME(x,y) if(y) pp_type |=x;
pp_type=0;
DOME(1,hzd);
DOME(2,vzd);
DOME(4,dring);
prefs->set(DEFAULT_POSTPROC_TYPE,pp_type);
prefs->set(DEFAULT_POSTPROC_VALUE,pp_value);
// Alsa
#ifdef ALSA_SUPPORT
if(alsaDevice)
{
prefs->set(DEVICE_AUDIO_ALSA_DEVICE, alsaDevice);
ADM_dealloc(alsaDevice);
alsaDevice=NULL;
}
#endif
// Device
//printf("[AudioDevice] Old : %d, new :%d\n",olddevice,newdevice);
if(olddevice!=newdevice)
{
AVDM_switch((AUDIO_DEVICE)newdevice); // Change current device
AVDM_audioSave(); // Save it in prefs
AVDM_audioInit(); // Respawn
}
// Downmixing (default)
prefs->set(DEFAULT_DOWNMIXING,downmix);
#if defined(ALSA_SUPPORT) || defined (OSS_SUPPORT)
// Master or PCM
prefs->set(FEATURES_AUDIOBAR_USES_MASTER, useMaster);
#endif
// allow non std audio fq for dvd
prefs->set(FEATURES_MPEG_NO_LIMIT, mpeg_no_limit);
// Video render
prefs->set(VIDEODEVICE,render);
// Odml
prefs->set(FEATURES_USE_ODML, use_odml);
// Split
prefs->set(MPEGSPLIT_AUTOSPLIT, autosplit);
// number of threads
prefs->set(FEATURES_THREADING_LAVC, lavcThreads);
// Encoding priority
prefs->set(PRIORITY_ENCODING, encodePriority);
// Indexing / unpacking priority
prefs->set(PRIORITY_INDEXING, indexPriority);
// Playback priority
prefs->set(PRIORITY_PLAYBACK, playbackPriority);
// Auto swap A/B
prefs->set(FEATURES_SWAP_IF_A_GREATER_THAN_B, useSwap);
//
prefs->set(MESSAGE_LEVEL,msglevel);
// Use tray while encoding
prefs->set(FEATURES_USE_SYSTRAY,useTray);
// VDPAU
prefs->set(FEATURES_VDPAU,bvdpau);
// Alternate mp3 tag (haali)
prefs->set(FEATURES_ALTERNATE_MP3_TAG,balternate_mp3_tag);
// Avisynth
prefs->set(AVISYNTH_AVISYNTH_DEFAULTPORT,defaultPortAvisynth);
prefs->set(AVISYNTH_AVISYNTH_ALWAYS_ASK, askPortAvisynth);
#if defined(_WIN32) && defined(USE_SDL)
// Initialise SDL again as driver may have changed
initSdl(render);
#endif
}
for(int i=0;i<nbAudioDevice+1;i++)
{
delete audioDeviceItems[i];
}
delete [] audioDeviceItems;
return 1;
}
uint8_t flvHeader::open(char *name)
{
uint32_t prevLen, type, size, pts,pos=0;
_isvideopresent=0;
_isaudiopresent=0;
audioTrack=NULL;
videoTrack=NULL;
_filename=ADM_strdup(name);
_fd=fopen(name,"rb");
if(!_fd)
{
printf("[FLV] Cannot open %s\n",name);
return 0;
}
// Get size
uint32_t fileSize=0;
fseeko(_fd,0,SEEK_END);
fileSize=ftello(_fd);
fseeko(_fd,0,SEEK_SET);
printf("[FLV] file size :%u bytes\n",fileSize);
// It must begin by F L V 01
uint8_t four[4];
read(4,four);
if(four[0]!='F' || four[1]!='L' || four[2]!='V')
{
printf("[FLV] Not a flv file %s\n",name);
return 0;
}
// Next one is flags
uint32_t flags=read8();
if(flags & 1) // VIDEO
{
_isvideopresent=1;
printf("[FLV] Video flag\n");
}else
{
GUI_Info_HIG(ADM_LOG_INFO,"Warning","This FLV file says it has no video.\nI will assume it has and try to continue");
_isvideopresent=1;
}
if(flags & 4) // Audio
{
_isaudiopresent=1;
printf("[FLV] Audio flag\n");
}
// Skip header
uint32_t skip=read32();
fseeko(_fd,skip,SEEK_SET);
printf("[FLV] Skipping %u header bytes\n",skip);
pos=ftello(_fd);;
printf("pos:%u/%u\n",pos,fileSize);
// Create our video index
videoTrack=new flvTrak(50);
if(_isaudiopresent)
audioTrack=new flvTrak(50);
else
audioTrack=NULL;
// Loop
while(pos<fileSize-14)
{
pos=ftello(_fd);
prevLen=read32();
type=read8();
size=read24();
pts=read24();
read32(); // ???
uint32_t remaining=size;
//printf("[FLV] At %08x found type %x size %u pts%u\n",pos,type,size,pts);
switch(type)
{
case FLV_TAG_TYPE_AUDIO:
{
if(!_isaudiopresent)
{
audioTrack=new flvTrak(50);
_isaudiopresent=1; /* Damn lying headers...*/
};
uint8_t flags=read8();
int of=1+4+3+3+1+4;
remaining--;
int format=flags>>4;
int fq=(flags>>2)&3;
int bps=(flags>>1) & 1;
int channel=(flags) & 1;
if(!audioTrack->_nbIndex) // first frame..
{
setAudioHeader(format,fq,bps,channel);
}
insertAudio(pos+of,remaining,pts);
}
break;
case FLV_TAG_TYPE_VIDEO:
{
int of=1+4+3+3+1+4;
uint8_t flags=read8();
remaining--;
int frameType=flags>>4;
int codec=(flags)&0xf;
if(codec==FLV_CODECID_VP6)
{
read8(); // 1 byte of extraData
remaining--;
of++;
}
int first=0;
if(!videoTrack->_nbIndex) first=1;
insertVideo(pos+of,remaining,frameType,pts);
if(first) // first frame..
{
if(!setVideoHeader(codec,&remaining)) return 0;
}
}
break;
default: printf("[FLV]At 0x%x, unhandled type %u\n",pos,type);
}
Skip(remaining);
} // while
// Udpate frame count etc..
printf("[FLV] Found %u frames\n",videoTrack->_nbIndex);
_videostream.dwLength= _mainaviheader.dwTotalFrames=videoTrack->_nbIndex;
// Compute average fps
float f=_videostream.dwLength;
uint32_t duration=videoTrack->_index[videoTrack->_nbIndex-1].timeCode;
if(duration)
f=1000.*1000.*f/duration;
else f=25000;
_videostream.dwRate=(uint32_t)floor(f);
_videostream.dwScale=1000;
_mainaviheader.dwMicroSecPerFrame=ADM_UsecFromFps1000(_videostream.dwRate);
printf("[FLV] Duration %u ms\n",videoTrack->_index[videoTrack->_nbIndex-1].timeCode);
//
_videostream.fccType=fourCC::get((uint8_t *)"vids");
_video_bih.biBitCount=24;
_videostream.dwInitialFrames= 0;
_videostream.dwStart= 0;
videoTrack->_index[0].flags=AVI_KEY_FRAME;
// audio track
_audioStream=new flvAudio(name,audioTrack,&wavHeader);
printf("[FLV]FLV successfully read\n");
return 1;
}
/**
\fn DIA_Preferences
\brief Handle preference dialog
*/
uint8_t DIA_Preferences(void)
{
uint32_t olddevice,newdevice;
uint32_t lavcodec_mpeg=0;
uint32_t use_odml=0;
uint32_t autosplit=0;
uint32_t render;
uint32_t useTray=0;
uint32_t useMaster=0;
uint32_t useAutoIndex=0;
uint32_t useSwap=0;
uint32_t useNuv=0;
uint32_t lavcThreads=0,x264Threads=0,xvidThreads=0;
uint32_t encodePriority=2;
uint32_t indexPriority=2;
uint32_t playbackPriority=0;
uint32_t downmix;
uint32_t mpeg_no_limit=0;
uint32_t msglevel=2;
uint32_t activeXfilter=0;
uint32_t mixer=0;
char *filterPath=NULL;
char *alsaDevice=NULL;
uint32_t autovbr=0;
uint32_t autoindex=0;
uint32_t autounpack=0;
uint32_t alternate_mp3_tag=1;
uint32_t pp_type=3;
uint32_t pp_value=5;
uint32_t hzd,vzd,dring;
uint32_t capsMMX,capsMMXEXT,caps3DNOW,caps3DNOWEXT,capsSSE,capsSSE2,capsSSE3,capsSSSE3,capsAll;
uint32_t useGlobalGlyph=0;
char *globalGlyphName=NULL;
olddevice=newdevice=AVDM_getCurrentDevice();
// Default pp
if(!prefs->get(DEFAULT_POSTPROC_TYPE,&pp_type)) pp_type=3;
if(!prefs->get(DEFAULT_POSTPROC_VALUE,&pp_value)) pp_value=3;
#define DOME(x,y) y=!!(pp_type & x)
DOME(1,hzd);
DOME(2,vzd);
DOME(4,dring);
// Cpu caps
#define CPU_CAPS(x) if(CpuCaps::myCpuMask & ADM_CPU_##x) caps##x=1; else caps##x=0;
if(CpuCaps::myCpuMask==ADM_CPU_ALL) capsAll=1; else capsAll=0;
CPU_CAPS(MMX);
CPU_CAPS(MMXEXT);
CPU_CAPS(3DNOW);
CPU_CAPS(3DNOWEXT);
CPU_CAPS(SSE);
CPU_CAPS(SSE2);
CPU_CAPS(SSE3);
CPU_CAPS(SSSE3);
// Alsa
#ifdef ALSA_SUPPORT
if( prefs->get(DEVICE_AUDIO_ALSA_DEVICE, &alsaDevice) != RC_OK )
alsaDevice = ADM_strdup("plughw:0,0");
#endif
// autovbr
prefs->get(FEATURE_AUTO_BUILDMAP,&autovbr);
// autoindex
prefs->get(FEATURE_AUTO_REBUILDINDEX,&autoindex);
// Global glyph
prefs->get(FEATURE_GLOBAL_GLYPH_ACTIVE,&useGlobalGlyph);
prefs->get(FEATURE_GLOBAL_GLYPH_NAME,&globalGlyphName);
// autoindex
prefs->get(FEATURE_AUTO_UNPACK,&autounpack);
// Alternate mp3 tag (haali)
prefs->get(FEATURE_ALTERNATE_MP3_TAG,&alternate_mp3_tag);
// Video renderer
if(prefs->get(DEVICE_VIDEODEVICE,&render)!=RC_OK)
{
render=(uint32_t)RENDER_GTK;
}
// SysTray
if(!prefs->get(FEATURE_USE_SYSTRAY,&useTray))
useTray=0;
// Accept mpeg for DVD when fq!=48 kHz
if(!prefs->get(FEATURE_MPEG_NO_LIMIT,&mpeg_no_limit)) mpeg_no_limit=0;
// Multithreads
prefs->get(FEATURE_THREADING_LAVC, &lavcThreads);
prefs->get(FEATURE_THREADING_X264, &x264Threads);
prefs->get(FEATURE_THREADING_XVID, &xvidThreads);
// Encoding priority
if(!prefs->get(PRIORITY_ENCODING, &encodePriority))
encodePriority=2;
// Indexing / unpacking priority
if(!prefs->get(PRIORITY_INDEXING, &indexPriority))
indexPriority=2;
// Playback priority
if(!prefs->get(PRIORITY_PLAYBACK, &playbackPriority))
playbackPriority=0;
// VCD/SVCD split point
if(!prefs->get(SETTINGS_MPEGSPLIT, &autosplit))
autosplit=690;
if(!prefs->get(FEATURE_USE_LAVCODEC_MPEG, &lavcodec_mpeg))
lavcodec_mpeg=0;
// Open DML (Gmv)
if(!prefs->get(FEATURE_USE_ODML, &use_odml))
use_odml=0;
#if defined(ALSA_SUPPORT) || defined (OSS_SUPPORT)
// Master or PCM for audio
if(!prefs->get(FEATURE_AUDIOBAR_USES_MASTER, &useMaster))
useMaster=0;
#endif
// Autoindex files
if(!prefs->get(FEATURE_TRYAUTOIDX, &useAutoIndex))
useAutoIndex=0;
// SWAP A&B if A>B
if(!prefs->get(FEATURE_SWAP_IF_A_GREATER_THAN_B, &useSwap))
useSwap=0;
// No nuv sync
if(!prefs->get(FEATURE_DISABLE_NUV_RESYNC, &useNuv))
useNuv=0;
// Get level of message verbosity
prefs->get(MESSAGE_LEVEL,&msglevel);
// External filter
prefs->get(FILTERS_AUTOLOAD_ACTIVE,&activeXfilter);
// Downmix default
if(prefs->get(DOWNMIXING_PROLOGIC,&downmix)!=RC_OK)
{
downmix=0;
}
olddevice=newdevice=AVDM_getCurrentDevice();
// Audio device
/************************ Build diaelems ****************************************/
diaElemToggle useSysTray(&useTray,QT_TR_NOOP("_Use systray while encoding"));
diaElemToggle allowAnyMpeg(&mpeg_no_limit,QT_TR_NOOP("_Accept non-standard audio frequency for DVD"));
diaElemToggle useLavcodec(&lavcodec_mpeg,QT_TR_NOOP("_Use libavcodec MPEG-2 decoder"));
diaElemToggle openDml(&use_odml,QT_TR_NOOP("Create _OpenDML files"));
diaElemToggle autoIndex(&useAutoIndex,QT_TR_NOOP("Automatically _index MPEG files"));
diaElemToggle autoSwap(&useSwap,QT_TR_NOOP("Automatically _swap A and B if A>B"));
diaElemToggle nuvAudio(&useNuv,QT_TR_NOOP("_Disable NUV audio sync"));
diaElemToggle togAutoVbr(&autovbr,QT_TR_NOOP("Automatically _build VBR map"));
diaElemToggle togAutoIndex(&autoindex,QT_TR_NOOP("Automatically _rebuild index"));
diaElemToggle togAutoUnpack(&autounpack,QT_TR_NOOP("Automatically remove _packed bitstream"));
diaElemFrame frameSimd(QT_TR_NOOP("SIMD"));
diaElemToggle capsToggleAll(&capsAll,QT_TR_NOOP("Enable all SIMD"));
diaElemToggle capsToggleMMX(&capsMMX, QT_TR_NOOP("Enable MMX"));
diaElemToggle capsToggleMMXEXT(&capsMMXEXT, QT_TR_NOOP("Enable MMXEXT"));
diaElemToggle capsToggle3DNOW(&caps3DNOW, QT_TR_NOOP("Enable 3DNOW"));
diaElemToggle capsToggle3DNOWEXT(&caps3DNOWEXT, QT_TR_NOOP("Enable 3DNOWEXT"));
diaElemToggle capsToggleSSE(&capsSSE, QT_TR_NOOP("Enable SSE"));
diaElemToggle capsToggleSSE2(&capsSSE2, QT_TR_NOOP("Enable SSE2"));
diaElemToggle capsToggleSSE3(&capsSSE3, QT_TR_NOOP("Enable SSE3"));
diaElemToggle capsToggleSSSE3(&capsSSSE3, QT_TR_NOOP("Enable SSSE3"));
capsToggleAll.link(0, &capsToggleMMX);
capsToggleAll.link(0, &capsToggleMMXEXT);
capsToggleAll.link(0, &capsToggle3DNOW);
capsToggleAll.link(0, &capsToggle3DNOWEXT);
capsToggleAll.link(0, &capsToggleSSE);
capsToggleAll.link(0, &capsToggleSSE2);
capsToggleAll.link(0, &capsToggleSSE3);
capsToggleAll.link(0, &capsToggleSSSE3);
frameSimd.swallow(&capsToggleAll);
frameSimd.swallow(&capsToggleMMX);
frameSimd.swallow(&capsToggleMMXEXT);
frameSimd.swallow(&capsToggle3DNOW);
frameSimd.swallow(&capsToggle3DNOWEXT);
frameSimd.swallow(&capsToggleSSE);
frameSimd.swallow(&capsToggleSSE2);
frameSimd.swallow(&capsToggleSSE3);
frameSimd.swallow(&capsToggleSSSE3);
diaElemThreadCount lavcThreadCount(&lavcThreads, QT_TR_NOOP("_lavc threads:"));
diaElemThreadCount x264ThreadCount(&x264Threads, QT_TR_NOOP("_x264 threads:"));
diaElemThreadCount xvidThreadCount(&xvidThreads, QT_TR_NOOP("X_vid threads:"));
diaElemFrame frameThread(QT_TR_NOOP("Multi-threading"));
frameThread.swallow(&lavcThreadCount);
frameThread.swallow(&x264ThreadCount);
frameThread.swallow(&xvidThreadCount);
diaMenuEntry priorityEntries[] = {
{0, QT_TR_NOOP("High"),NULL}
,{1, QT_TR_NOOP("Above normal"),NULL}
,{2, QT_TR_NOOP("Normal"),NULL}
,{3, QT_TR_NOOP("Below normal"),NULL}
,{4, QT_TR_NOOP("Low"),NULL}
};
diaElemMenu menuEncodePriority(&encodePriority,QT_TR_NOOP("_Encoding priority:"), sizeof(priorityEntries)/sizeof(diaMenuEntry), priorityEntries,"");
diaElemMenu menuIndexPriority(&indexPriority,QT_TR_NOOP("_Indexing/unpacking priority:"), sizeof(priorityEntries)/sizeof(diaMenuEntry), priorityEntries,"");
diaElemMenu menuPlaybackPriority(&playbackPriority,QT_TR_NOOP("_Playback priority:"), sizeof(priorityEntries)/sizeof(diaMenuEntry), priorityEntries,"");
diaElemFrame framePriority(QT_TR_NOOP("Prioritisation"));
framePriority.swallow(&menuEncodePriority);
framePriority.swallow(&menuIndexPriority);
framePriority.swallow(&menuPlaybackPriority);
diaElemUInteger autoSplit(&autosplit,QT_TR_NOOP("_Split MPEG files every (MB):"),10,4096);
diaElemToggle togTagMp3(&alternate_mp3_tag,QT_TR_NOOP("_Use alternative tag for MP3 in .mp4"));
diaMenuEntry videoMode[]={
{RENDER_GTK, QT_TR_NOOP("GTK+ (slow)"),NULL}
#ifdef USE_XV
,{RENDER_XV, QT_TR_NOOP("XVideo (best)"),NULL}
#endif
#ifdef USE_SDL
#ifdef ADM_WIN32
,{RENDER_SDL, QT_TR_NOOP("SDL (GDI)"),NULL}
,{RENDER_DIRECTX, QT_TR_NOOP("SDL (DirectX)"),NULL}
#else
,{RENDER_SDL, QT_TR_NOOP("SDL (good)"),NULL}
#endif
#endif
};
diaElemMenu menuVideoMode(&render,QT_TR_NOOP("Video _display:"), sizeof(videoMode)/sizeof(diaMenuEntry),videoMode,"");
diaMenuEntry msgEntries[]={
{0, QT_TR_NOOP("No alerts"),NULL}
,{1, QT_TR_NOOP("Display only error alerts"),NULL}
,{2, QT_TR_NOOP("Display all alerts"),NULL}
};
diaElemMenu menuMessage(&msglevel,QT_TR_NOOP("_Message level:"), sizeof(msgEntries)/sizeof(diaMenuEntry),msgEntries,"");
#if defined(ALSA_SUPPORT) || defined (OSS_SUPPORT)
diaMenuEntry volumeEntries[]={
{0, QT_TR_NOOP("PCM"),NULL}
,{1, QT_TR_NOOP("Master"),NULL}};
diaElemMenu menuVolume(&useMaster,QT_TR_NOOP("_Volume control:"), sizeof(volumeEntries)/sizeof(diaMenuEntry),volumeEntries,"");
#endif
diaMenuEntry mixerEntries[]={
{0, QT_TR_NOOP("No downmixing"),NULL}
,{1, QT_TR_NOOP("Stereo"),NULL}
,{2, QT_TR_NOOP("Pro Logic"),NULL}
,{3, QT_TR_NOOP("Pro Logic II"),NULL}
};
diaElemMenu menuMixer(&downmix,QT_TR_NOOP("_Local playback downmixing:"), sizeof(mixerEntries)/sizeof(diaMenuEntry),mixerEntries,"");
diaMenuEntry audioEntries[] =
{
#ifdef ALSA_SUPPORT
{DEVICE_ALSA, QT_TR_NOOP("ALSA")},
#endif
#ifdef USE_ARTS
{DEVICE_ARTS, QT_TR_NOOP("aRts")},
#endif
#ifdef CONFIG_DARWIN
{DEVICE_COREAUDIO, QT_TR_NOOP("Core Audio")},
#endif
#ifdef USE_ESD
{DEVICE_ESD, QT_TR_NOOP("ESD")},
#endif
#ifdef USE_JACK
{DEVICE_JACK, QT_TR_NOOP("JACK")},
#endif
#ifdef OSS_SUPPORT
{DEVICE_OSS, QT_TR_NOOP("OSS")},
#endif
#ifdef USE_PULSE_SIMPLE
{DEVICE_PULSE_SIMPLE, QT_TR_NOOP("Pulse Audio")},
#endif
#if defined(USE_SDL) && !defined(ADM_WIN32)
{DEVICE_SDL, QT_TR_NOOP("SDL")},
#endif
#ifdef ADM_WIN32
{DEVICE_WIN32, QT_TR_NOOP("Win32")},
#endif
{DEVICE_DUMMY, QT_TR_NOOP("None")}
};
diaElemMenu menuAudio(&newdevice,QT_TR_NOOP("_Audio output:"), sizeof(audioEntries)/sizeof(diaMenuEntry),audioEntries,"");
#ifdef ALSA_SUPPORT
diaElemText entryAlsaDevice(&alsaDevice,QT_TR_NOOP("ALSA _device:"),NULL);
int z,m;
m=sizeof(audioEntries)/sizeof(diaMenuEntry);
for(z=0;z<m;z++)
{
if(audioEntries[z].val==DEVICE_ALSA)
menuAudio.link(&(audioEntries[z]),1,&entryAlsaDevice);
}
#endif
// default Post proc
diaElemToggle fhzd(&hzd,QT_TR_NOOP("_Horizontal deblocking"));
diaElemToggle fvzd(&vzd,QT_TR_NOOP("_Vertical deblocking"));
diaElemToggle fdring(&dring,QT_TR_NOOP("De_ringing"));
diaElemUInteger postProcStrength(&pp_value,QT_TR_NOOP("_Strength:"),0,5);
diaElemFrame framePP(QT_TR_NOOP("Default Postprocessing"));
framePP.swallow(&fhzd);
framePP.swallow(&fvzd);
framePP.swallow(&fdring);
framePP.swallow(&postProcStrength);
// Filter path
if( prefs->get(FILTERS_AUTOLOAD_PATH, &filterPath) != RC_OK )
#ifndef ADM_WIN32
filterPath = ADM_strdup("/tmp");
#else
filterPath = ADM_strdup("c:\\");
#endif
diaElemDirSelect entryFilterPath(&filterPath,QT_TR_NOOP("_Filter directory:"),QT_TR_NOOP("Select filter directory"));
diaElemToggle loadEx(&activeXfilter,QT_TR_NOOP("_Load external filters"));
loadEx.link(1, &entryFilterPath);
diaElemToggle togGlobalGlyph(&useGlobalGlyph, QT_TR_NOOP("Use _Global GlyphSet"));
diaElemFile entryGLyphPath(0,&globalGlyphName,QT_TR_NOOP("Gl_yphSet:"), NULL, QT_TR_NOOP("Select GlyphSet file"));
togGlobalGlyph.link(1, &entryGLyphPath);
/* User Interface */
diaElem *diaUser[]={&useSysTray,&menuMessage};
diaElemTabs tabUser(QT_TR_NOOP("User Interface"),2,diaUser);
/* Automation */
diaElem *diaAuto[]={&autoSwap,&togAutoVbr,&togAutoIndex,&togAutoUnpack,&autoIndex,};
diaElemTabs tabAuto(QT_TR_NOOP("Automation"),5,diaAuto);
/* Input */
diaElem *diaInput[]={&nuvAudio,&useLavcodec};
diaElemTabs tabInput(QT_TR_NOOP("Input"),2,(diaElem **)diaInput);
/* Output */
diaElem *diaOutput[]={&autoSplit,&openDml,&allowAnyMpeg,&togTagMp3};
diaElemTabs tabOutput(QT_TR_NOOP("Output"),4,(diaElem **)diaOutput);
/* Audio */
#if defined(ALSA_SUPPORT)
diaElem *diaAudio[]={&menuMixer,&menuVolume,&menuAudio,&entryAlsaDevice};
diaElemTabs tabAudio(QT_TR_NOOP("Audio"),4,(diaElem **)diaAudio);
#elif defined(OSS_SUPPORT)
diaElem *diaAudio[]={&menuMixer,&menuVolume,&menuAudio};
diaElemTabs tabAudio(QT_TR_NOOP("Audio"),3,(diaElem **)diaAudio);
#else
diaElem *diaAudio[]={&menuMixer,&menuAudio};
diaElemTabs tabAudio(QT_TR_NOOP("Audio"),2,(diaElem **)diaAudio);
#endif
/* Video */
diaElem *diaVideo[]={&menuVideoMode,&framePP};
diaElemTabs tabVideo(QT_TR_NOOP("Video"),2,(diaElem **)diaVideo);
/* CPU tab */
diaElem *diaCpu[]={&frameSimd};
diaElemTabs tabCpu(QT_TR_NOOP("CPU"),1,(diaElem **)diaCpu);
/* Threading tab */
diaElem *diaThreading[]={&frameThread, &framePriority};
diaElemTabs tabThreading(QT_TR_NOOP("Threading"),2,(diaElem **)diaThreading);
/* Global Glyph tab */
diaElem *diaGlyph[]={&togGlobalGlyph,&entryGLyphPath};
diaElemTabs tabGlyph(QT_TR_NOOP("Global GlyphSet"),2,(diaElem **)diaGlyph);
/* Xfilter tab */
diaElem *diaXFilter[]={&loadEx,&entryFilterPath};
diaElemTabs tabXfilter(QT_TR_NOOP("External Filters"),2,(diaElem **)diaXFilter);
// SET
diaElemTabs *tabs[]={&tabUser,&tabAuto,&tabInput,&tabOutput,&tabAudio,&tabVideo,&tabCpu,&tabThreading,&tabGlyph,&tabXfilter};
if( diaFactoryRunTabs(QT_TR_NOOP("Preferences"),10,tabs))
{
// cpu caps
if(capsAll)
{
CpuCaps::myCpuMask=ADM_CPU_ALL;
}else
{
CpuCaps::myCpuMask=0;
#undef CPU_CAPS
#define CPU_CAPS(x) if(caps##x) CpuCaps::myCpuMask|= ADM_CPU_##x;
CPU_CAPS(MMX);
CPU_CAPS(MMXEXT);
CPU_CAPS(3DNOW);
CPU_CAPS(3DNOWEXT);
CPU_CAPS(SSE);
CPU_CAPS(SSE2);
CPU_CAPS(SSE3);
CPU_CAPS(SSSE3);
}
prefs->set(FEATURE_CPU_CAPS,CpuCaps::myCpuMask);
// Glyphs
prefs->set(FEATURE_GLOBAL_GLYPH_ACTIVE,useGlobalGlyph);
prefs->set(FEATURE_GLOBAL_GLYPH_NAME,globalGlyphName);
// Postproc
#undef DOME
#define DOME(x,y) if(y) pp_type |=x;
pp_type=0;
DOME(1,hzd);
DOME(2,vzd);
DOME(4,dring);
prefs->set(DEFAULT_POSTPROC_TYPE,pp_type);
prefs->set(DEFAULT_POSTPROC_VALUE,pp_value);
//
prefs->set(FEATURE_AUTO_UNPACK,autounpack);
// autovbr
prefs->set(FEATURE_AUTO_BUILDMAP,autovbr);
// autoindex
prefs->set(FEATURE_AUTO_REBUILDINDEX,autoindex);
// Alsa
#ifdef ALSA_SUPPORT
if(alsaDevice)
{
prefs->set(DEVICE_AUDIO_ALSA_DEVICE, alsaDevice);
ADM_dealloc(alsaDevice);
alsaDevice=NULL;
}
#endif
// Device
if(olddevice!=newdevice)
{
AVDM_switch((AUDIO_DEVICE)newdevice);
}
// Downmixing (default)
prefs->set(DOWNMIXING_PROLOGIC,downmix);
#if defined(ALSA_SUPPORT) || defined (OSS_SUPPORT)
// Master or PCM
prefs->set(FEATURE_AUDIOBAR_USES_MASTER, useMaster);
#endif
// allow non std audio fq for dvd
prefs->set(FEATURE_MPEG_NO_LIMIT, mpeg_no_limit);
// Video render
prefs->set(DEVICE_VIDEODEVICE,render);
// Mpeg /lavcodec
prefs->set(FEATURE_USE_LAVCODEC_MPEG, lavcodec_mpeg);
// Odml
prefs->set(FEATURE_USE_ODML, use_odml);
// Split
prefs->set(SETTINGS_MPEGSPLIT, autosplit);
// number of threads
prefs->set(FEATURE_THREADING_LAVC, lavcThreads);
prefs->set(FEATURE_THREADING_X264, x264Threads);
prefs->set(FEATURE_THREADING_XVID, xvidThreads);
// Encoding priority
prefs->set(PRIORITY_ENCODING, encodePriority);
// Indexing / unpacking priority
prefs->set(PRIORITY_INDEXING, indexPriority);
// Playback priority
prefs->set(PRIORITY_PLAYBACK, playbackPriority);
// Auto index mpeg
prefs->set(FEATURE_TRYAUTOIDX, useAutoIndex);
// Auto swap A/B
prefs->set(FEATURE_SWAP_IF_A_GREATER_THAN_B, useSwap);
// Disable nuv sync
prefs->set(FEATURE_DISABLE_NUV_RESYNC, useNuv);
// Use tray while encoding
prefs->set(FEATURE_USE_SYSTRAY,useTray);
// Filter directory
prefs->set(FILTERS_AUTOLOAD_ACTIVE, activeXfilter);
if(filterPath)
prefs->set(FILTERS_AUTOLOAD_PATH, filterPath);
// Alternate mp3 tag (haali)
prefs->set(FEATURE_ALTERNATE_MP3_TAG,alternate_mp3_tag);
#if defined(ADM_WIN32) && defined(USE_SDL)
// Initialise SDL again as driver may have changed
initSdl();
#endif
}
ADM_dealloc(filterPath);
ADM_dealloc(globalGlyphName);
return 1;
}
uint8_t amvHeader::open(char *name)
{
uint32_t prevLen, type, size, pts,pos=0;
_isvideopresent=0;
_isaudiopresent=0;
memset(&_mainaviheader,0,sizeof(_mainaviheader));
_filename=ADM_strdup(name);
_fd=fopen(name,"rb");
if(!_fd)
{
printf("[AMV] Cannot open %s\n",name);
return 0;
}
// Get size
uint32_t fileSize=0;
fseeko(_fd,0,SEEK_END);
fileSize=ftello(_fd);
fseeko(_fd,0,SEEK_SET);
printf("[AMV] file size :%u bytes\n",fileSize);
// It must begin by F L V 01
uint32_t four=read32();
if(four!=MKFCC('R','I','F','F'))
{
printf("[AMV] Not a riff file\n");
return 0;
}
uint32_t s=read32(); // size;
if(s<fileSize) fileSize=s;
if(read32()!=MKFCC('A','M','V',' '))
{
// Not an AMV file
printf("[AMV] Not an AMV file\n");
return 0;
}
int hdr,list,nbTrack=0;
while((list=read32())==MKFCC('L','I','S','T'))
{
printf("[AMV] List\n");
read32();
hdr=read32();
switch(hdr)
{
case MKFCC('h','d','r','l'):
printf("\t[AMV] Header\n");
if(!readHeader()) return 0;
printf("\t[AMV] Header Ok\n");
break;
case MKFCC('s','t','r','l'):
printf("\t[AMV] Track\n");
if(!readTrack(nbTrack)) return 0;
nbTrack++;
printf("\t[AMV] Track Ok\n");
break;
case MKFCC('m','o','v','i'):
printf("\t[AMV] Indexing\n");
if(!index()) return 0;
printf("\t[AMV] Indexing Ok\n");
break;
default:
printf("[AMV] Last :%s",fourCC::tostring(hdr));
ADM_assert(0);
}
}
if(videoTrack.index) videoTrack.index[0].flags=AVI_KEY_FRAME;
else return 0;
_isvideopresent=1;
// Build a fake stream/bih bih
#define ENTRY(x,y) _videostream.x=y
uint32_t codec=MKFCC('A','M','V',' ');
ENTRY( fccType,MKFCC('v','i','d','s'));
ENTRY( fccHandler,codec);
ENTRY( dwInitialFrames,0);
ENTRY( dwScale,1000);
ENTRY( dwRate,8000); /* dwRate / dwScale == samples/second */
// _video_bih
#undef ENTRY
#define ENTRY(x,y) _video_bih.x=y
ENTRY(biWidth,_mainaviheader.dwWidth);
ENTRY(biHeight,_mainaviheader.dwHeight);
ENTRY(biCompression,codec);
printf("[AMV] Dimension %u * %u\n",_video_bih.biWidth,_video_bih.biHeight);
// If audio...
if(audioTrack.index)
{
_isaudiopresent=1;
_audio=new amvAudio(name,&audioTrack,&wavHeader);
}
return 1;
}
diaElemBar::diaElemBar(uint32_t percent,const char *toggleTitle)
: diaElem(ELEM_BAR)
{
per=percent;
paramTitle=ADM_strdup(toggleTitle);
}
uint8_t DIA_vobsub(vobSubParam *param)
{
char *name=NULL;
int32_t shift;
int ret,ext,r;
ret=0;
ext=0;
if(param->subname)
name=ADM_strdup(param->subname);
shift=param->subShift;
while(!ext)
{
dialog=create_dialog1();
gtk_register_dialog(dialog);
//gtk_transient(dialog);
gtk_dialog_add_action_widget (GTK_DIALOG (dialog), WID(buttonSelect), GTK_RESPONSE_APPLY);
fq=new GtkWidget*[ADM_MAX_LANGUAGE];
// Upload if any
if(name)
{
update(name,param->index);
}
else
{
gtk_label_set_text(GTK_LABEL(WID(labelVobsub)),QT_TR_NOOP("none"));
}
gtk_write_entry(WID(entryShift),shift);
r=gtk_dialog_run(GTK_DIALOG(dialog));
shift=gtk_read_entry(WID(entryShift));
switch(r)
{
case GTK_RESPONSE_APPLY:
{
char *file;
GUI_FileSelRead(QT_TR_NOOP("Select .idx file"),&file);
if(file)
{
if(name) ADM_dealloc(name);
name=NULL;
name=ADM_strdup(file); // Leak ?
}
}
break;
case GTK_RESPONSE_OK:
ret=1;
ext=1;
if(name)
{
ADM_dealloc(name);
}
name=ADM_strdup(gtk_label_get_text(GTK_LABEL(WID(labelVobsub))));
if(param->subname)
ADM_dealloc(param->subname);
param->subname=name;
//
param->index=indeces[getRangeInMenu(WID(optionmenu1))];
param->subShift=shift;
break;
case GTK_RESPONSE_CANCEL:
ret=0;
ext=1;
break;
default:
break;
}
delete [] fq;
gtk_unregister_dialog(dialog);
gtk_widget_destroy(dialog);
}
return ret;
}
//______________________________________________________
// Check and build a confCouple from the args
// the filter_param arg is a template for that filter
//______________________________________________________
CONFcouple *filterBuildCouple(FILTER_PARAM *param,uint32_t nb,Arg *args)
{
int found,l;
int trans[MAXPARAM];
if(param->nb>VARIABLE_PARAMS)
{
// Variable # of parameters
// We check we have at least what is required by the template
for(int i=0;i<(param->nb-VARIABLE_PARAMS);i++)
{
l=strlen(param->param[i]);
ADM_assert(l);
found=-1;
for(int j=0;j<nb;j++)
{
if(!strncasecmp(param->param[i],args[j].arg.string,l))
{
if(strlen(args[j].arg.string)>l && args[j].arg.string[l]=='=')
{
found=j;
break;
}
}
}
if(found==-1)
{
printf("Param : %s not found or incorrect\n",param->param[i]);
return NULL;
}
}
// if we get here, it means we found each param, time to build the couples
CONFcouple *couple;
couple=new CONFcouple(nb);
for(int i=0;i<nb;i++)
{
char *copy=ADM_strdup(args[i].arg.string);
// Search "="
char *where=strstr(copy,"=");
if(!where) ADM_assert(0);
*where=0;
if(!couple->setCouple(copy,where+1))
{
printf("Set couple failed\n");
delete couple;
return NULL;
}
ADM_dealloc(copy);
}
return couple;
}
//********************* Constant # of parameters #################
else
{
if(nb!=param->nb )
{
printf("# of parameters mismatch: expected %d, got %d\n",nb,param->nb);
return NULL;
}
// For each param check we are ok
// the generic form is name=value
// name should be the same as in the param array
for(int i=0;i<nb;i++)
{
l=strlen(param->param[i]);
ADM_assert(l);
found=-1;
for(int j=0;j<nb;j++)
{
if(!strncasecmp(param->param[i],args[j].arg.string,l))
{
if(strlen(args[j].arg.string)>l && args[j].arg.string[l]=='=')
{
found=j;
trans[i]=j;
break;
}
}
}
if(found==-1)
{
printf("Param : %s not found or incorrect\n",param->param[i]);
return NULL;
}
}
// if we get here, it means we found each param, time to build the couples
CONFcouple *couple;
couple=new CONFcouple(nb);
for(int i=0;i<nb;i++)
{
l=strlen(param->param[i]);
if(!couple->setCouple(param->param[i],args[ trans[i]].arg.string+l+1))
{
printf("Set couple failed\n");
delete couple;
return NULL;
}
}
return couple;
}
}
/*
Get the root directory for .avidemux stuff
******************************************************/
char *ADM_getBaseDir(void)
{
char *home;
if (baseDirDone)
return ADM_basedir;
// Get the base directory
#ifdef __WIN32
wchar_t wcHome[MAX_PATH];
if (SHGetFolderPathW(NULL, CSIDL_APPDATA, NULL, 0, wcHome) == S_OK)
{
int len = wideCharStringToUtf8(wcHome, -1, NULL);
home = new char[len];
wideCharStringToUtf8(wcHome, -1, home);
}
else
{
printf("Oops: can't determine the Application Data folder.");
home = ADM_strdup("c:\\");
}
#else
const char* homeEnv = getenv("HOME");
if (homeEnv)
{
home = new char[strlen(homeEnv) + 1];
strcpy(home, homeEnv);
}
else
{
printf("Oops: can't determine $HOME.");
return NULL;
}
#endif
// Try to open the .avidemux directory
char *dirname = new char[strlen(home) + strlen(ADM_DIR_NAME) + 2];
strcpy(dirname, home);
strcat(dirname, ADM_DIR_NAME);
if (!ADM_mkdir(dirname))
{
printf("Oops: cannot create the .avidemux directory", NULL);
delete [] dirname;
return NULL;
}
delete [] dirname;
// Now built the filename
strncpy(ADM_basedir,home, 1023);
strncat(ADM_basedir, ADM_DIR_NAME, 1023 - strlen(ADM_basedir));
baseDirDone = 1;
printf("Using %s as base directory for prefs/jobs/...\n", ADM_basedir);
return ADM_basedir;
}
/**
\fn DIA_ocrDvb
\brief Dialog to select input & output files before calling the actual ocr engine
*/
uint8_t DIA_ocrDvb(void)
{
vobSubParam subparam={NULL,0,0};
char *srtFileName=NULL;
char *glyphFileName=NULL;
char *tsFileName=NULL;
admGlyph head(16,16);
char *globalGlyph=NULL;
uint32_t globalGlyphOn=0;
uint32_t pid=0x96;
ADM_OCR_SOURCE source;
memset(&source,0,sizeof(source));
source.type=ADM_OCR_TYPE_TS;
prefs->get(FEATURE_GLOBAL_GLYPH_ACTIVE,&globalGlyphOn);
if(globalGlyphOn)
{
prefs->get(FEATURE_GLOBAL_GLYPH_NAME,&globalGlyph);
if(!*globalGlyph)
{
ADM_dezalloc(globalGlyph);
globalGlyph=NULL;
}
}
if(globalGlyph)
{
glyphFileName=globalGlyph;
}
_againX:
// Fist build a dialogFactory to get input and output files
diaElemFile selectTs(1,&tsFileName,QT_TR_NOOP("Input TS:"), NULL, QT_TR_NOOP("Select TS file"));
diaElemUInteger selectPid(&pid,QT_TR_NOOP("Subtitle PID:"),0,255);
diaElemFile selectGlyph(1,&glyphFileName,QT_TR_NOOP("Use glyphset (optional):"), NULL, QT_TR_NOOP("Select GlyphSet file"));
diaElemFile selectSrt(1,&srtFileName,QT_TR_NOOP("Output SRT file"), NULL, QT_TR_NOOP("Save SRT file"));
diaElem *elems[]={&selectTs,&selectPid,&selectSrt,&selectGlyph};
uint32_t n=4;
if(globalGlyph)
{
n--; // Remove glyph from dialog
}
if( !diaFactoryRun(QT_TR_NOOP("Select input and ouput files"),n,elems))
{
cleanupSub(&source);
if(srtFileName )ADM_dezalloc(srtFileName);
srtFileName=NULL;
destroyGlyphTree(&head);
return 0;
}
// TS file exists ?
if(!ADM_fileExist(tsFileName))
{
GUI_Error_HIG(QT_TR_NOOP("File error"),QT_TR_NOOP("Please Select a valid TS file."));
goto _againX;
}
if(!srtFileName || !*srtFileName)
{
GUI_Error_HIG(QT_TR_NOOP("File error"),QT_TR_NOOP("Please Select a valid output SRT file."));
goto _againX;
}
if(glyphFileName && *glyphFileName)
{
if(!ADM_fileExist(glyphFileName))
{
GUI_Error_HIG(QT_TR_NOOP("File error"),QT_TR_NOOP("The idx/sub file does not exist."));
goto _againX;
}
// Purge previous glyph set if any
destroyGlyphTree(&head);
uint32_t nb;
printf("[OCR] Loading glyphset :<%s>\n",glyphFileName);
if(!loadGlyph(glyphFileName,&head,&nb))
{
GUI_Error_HIG(QT_TR_NOOP("File error"),QT_TR_NOOP("Cannot load the glyphset file."));
goto _againX;
}
printf("[GLYPH] Found %u glyph\n");
}
// We have our SRT and our TS file
// Call the OCR engine...
source.TsFile=ADM_strdup(tsFileName);
source.TsPid=pid;
ADM_ocr_engine(source,srtFileName,&head);
// Save glyph set
if(globalGlyph)
{
uint32_t nb=1;
saveGlyph(globalGlyph,&head,nb);
}else
{
char *save=NULL;
uint32_t nb=1;
diaElemFile selectSave(1,&save,QT_TR_NOOP("GlyphSet filename"), NULL, QT_TR_NOOP("Save GlyphSet file"));
diaElem *elems2[]={&selectSave};
if( diaFactoryRun(QT_TR_NOOP("Save GlyphSet"),1,elems2))
{
saveGlyph(save,&head,nb);
}
if(save) ADM_dezalloc(save);
}
cleanupSub(&source);
if(srtFileName )ADM_dezalloc(srtFileName);
srtFileName=NULL;
if(tsFileName )ADM_dezalloc(tsFileName);
tsFileName=NULL;
destroyGlyphTree(&head);
return 1;
}
uint8_t mkvHeader::open(const char *name)
{
ADM_ebml_file ebml;
uint64_t id,len;
uint64_t alen;
ADM_MKV_TYPE type;
const char *ss;
_isvideopresent=0;
if(!ebml.open(name))
{
printf("[MKV]Failed to open file\n");
return 0;
}
if(!ebml.find(ADM_MKV_PRIMARY,EBML_HEADER,(MKV_ELEM_ID)0,&alen))
{
printf("[MKV] Cannot find header\n");
return 0;
}
if(!checkHeader(&ebml,alen))
{
printf("[MKV] Incorrect Header\n");
return 0;
}
/* Now find tracks */
if(!ebml.find(ADM_MKV_SECONDARY,MKV_SEGMENT,MKV_TRACKS,&alen))
{
printf("[MKV] Cannot find tracks\n");
return 0;
}
/* And analyze them */
if(!analyzeTracks(&ebml,alen))
{
printf("[MKV] incorrect tracks\n");
}
printf("[MKV] Tracks analyzed\n");
if(!_isvideopresent)
{
printf("[MKV] No video\n");
return 0;
}
printf("[MKV] Indexing clusters\n");
if(!indexClusters(&ebml))
{
printf("[MKV] Cluster indexing failed\n");
return 0;
}
printf("[MKV]Found %u clusters\n",_nbClusters);
printf("[MKV] Indexing video\n");
if(!videoIndexer(&ebml))
{
printf("[MKV] Video indexing failed\n");
return 0;
}
// update some infos
_videostream.dwLength= _mainaviheader.dwTotalFrames=_tracks[0]._nbIndex;
_parser=new ADM_ebml_file();
ADM_assert(_parser->open(name));
_filename=ADM_strdup(name);
// Finaly update index with queue
float duration=_videostream.dwLength*_tracks[0]._defaultFrameDuration;
duration/=1000;
uint32_t duration32=(uint32_t)duration;
printf("[MKV] Video Track duration %u ms\n",_videostream.dwLength);
// Useless.....readCue(&ebml);
for(int i=0;i<_nbAudioTrack;i++)
{
rescaleTrack(&(_tracks[1+i]),duration32);
if(_tracks[1+i].wavHeader.encoding==WAV_OGG)
{
printf("[MKV] Reformatting vorbis header for track %u\n",i);
reformatVorbisHeader(&(_tracks[1+i]));
}
}
printf("[MKV]Matroska successfully read\n");
return 1;
}
ReplyType glyphToText(admGlyph *glyph,admGlyph *head,char *decodedString)
{
admGlyph *cand;
//printf("2t: %d x %d\n",glyph->width,glyph->height);
if(glyph->width<2 && glyph->height<2)
{
delete glyph;
return ReplyOk;
}
cand=searchGlyph(head,glyph);
if(!cand) // New glyph
{
char *string;
// Draw it
displaySmall(glyph);
gtk_label_set_text(GTK_LABEL(WID(labelText)),decodedString);
gtk_editable_delete_text(GTK_EDITABLE(WID(entry)), 0,-1);
//gtk_widget_set_sensitive(WID(buttonAccept),1);
//gtk_widget_set_sensitive(WID(buttonSkip),1);
//gtk_widget_set_sensitive(WID(entryEntry),1);
gtk_widget_grab_focus (WID(entry));
gtk_widget_grab_default (WID(buttonOk));
//printf("i\n");
switch(gtk_dialog_run(GTK_DIALOG(dialog)))
{
case actionIgnore:
glyph->code=NULL;
insertInGlyphTree(head,glyph);
//*nbGl++;
break;
case actionCalibrate: return ReplyCalibrate;
case actionAccept:
string =gtk_editable_get_chars(GTK_EDITABLE (WID(entry)), 0, -1);
if(string&& strlen(string))
{
glyph->code=ADM_strdup(string);
insertInGlyphTree(head,glyph);
//printf("New glyph:%s\n",glyph->code);
strcat(decodedString,glyph->code);
//*nbGl++;
}
else delete glyph;
break;
case actionSkip: //SKIP
return ReplySkip;
break;
case actionSkipAll:
return ReplySkipAll;
break;
case GTK_RESPONSE_CLOSE:
if(GUI_Question(QT_TR_NOOP("Sure ?"))) return ReplyClose;
break; // Abort
}
gtk_editable_delete_text(GTK_EDITABLE(WID(entry)), 0,-1);
//gtk_widget_set_sensitive(WID(buttonAccept),0);
//gtk_widget_set_sensitive(WID(buttonSkip),0);
//gtk_widget_set_sensitive(WID(entryEntry),0);
}
else
{
//printf("Glyph known :%s \n",cand->code);
if(cand->code)
strcat(decodedString,cand->code);
delete glyph;
}
return ReplyOk;
}
int preferences::set_lastfile(const char* file){
char *internal_file;
if( ! file ){
fprintf(stderr,"Prefs: set_lastfile(NULL) called\n");
return RC_FAILED;
}
internal_file = ADM_PathCanonize(file);
if( !internal_file ){
fprintf(stderr,"Prefs: set_lastfile(): PathCanonize() returns NULL\n");
return RC_FAILED;
}
#ifdef DEBUG_PREFS
fprintf(stderr,"Prefs: set_lastfile(%s)\n",file);
if( strcmp(file,internal_file) )
fprintf(stderr,"Prefs: set_lastfile(%s) (with appended current dir)\n",internal_file);
PRT_LAFI("<= LASTFILES_",1,opt_defs[LASTFILES_FILE1].current_val);
PRT_LAFI("<= LASTFILES_",2,opt_defs[LASTFILES_FILE2].current_val);
PRT_LAFI("<= LASTFILES_",3,opt_defs[LASTFILES_FILE3].current_val);
PRT_LAFI("<= LASTFILES_",4,opt_defs[LASTFILES_FILE4].current_val);
#endif
// change opt_defs array
//
// ToDo:
// * a call with a file already in lastfiles will resort lastfiles with
// the actual argument on top
// * a call with a file new to lastfiles will drop LASTFILE_4, move all
// one step down and add the file as LASTFILE_1
if( opt_defs[LASTFILES_FILE4].current_val &&
!strncmp(opt_defs[LASTFILES_FILE4].current_val,internal_file,strlen(opt_defs[LASTFILES_FILE4].current_val)) ){
char *x = opt_defs[LASTFILES_FILE4].current_val;
opt_defs[LASTFILES_FILE4].current_val = opt_defs[LASTFILES_FILE3].current_val;
opt_defs[LASTFILES_FILE3].current_val = opt_defs[LASTFILES_FILE2].current_val;
opt_defs[LASTFILES_FILE2].current_val = opt_defs[LASTFILES_FILE1].current_val;
opt_defs[LASTFILES_FILE1].current_val = x;
}else if( opt_defs[LASTFILES_FILE3].current_val &&
!strncmp(opt_defs[LASTFILES_FILE3].current_val,internal_file,strlen(opt_defs[LASTFILES_FILE3].current_val)) ){
char *x = opt_defs[LASTFILES_FILE3].current_val;
opt_defs[LASTFILES_FILE3].current_val = opt_defs[LASTFILES_FILE2].current_val;
opt_defs[LASTFILES_FILE2].current_val = opt_defs[LASTFILES_FILE1].current_val;
opt_defs[LASTFILES_FILE1].current_val = x;
}else if( opt_defs[LASTFILES_FILE2].current_val &&
!strncmp(opt_defs[LASTFILES_FILE2].current_val,internal_file,strlen(opt_defs[LASTFILES_FILE2].current_val)) ){
char *x = opt_defs[LASTFILES_FILE2].current_val;
opt_defs[LASTFILES_FILE2].current_val = opt_defs[LASTFILES_FILE1].current_val;
opt_defs[LASTFILES_FILE1].current_val = x;
}else if( opt_defs[LASTFILES_FILE1].current_val &&
!strncmp(opt_defs[LASTFILES_FILE1].current_val,internal_file,strlen(opt_defs[LASTFILES_FILE1].current_val)) ){
; // nothing to do - always on top
}else{
if( opt_defs[LASTFILES_FILE4].current_val )
ADM_dealloc(opt_defs[LASTFILES_FILE4].current_val);
opt_defs[LASTFILES_FILE4].current_val = opt_defs[LASTFILES_FILE3].current_val;
opt_defs[LASTFILES_FILE3].current_val = opt_defs[LASTFILES_FILE2].current_val;
opt_defs[LASTFILES_FILE2].current_val = opt_defs[LASTFILES_FILE1].current_val;
opt_defs[LASTFILES_FILE1].current_val = ADM_strdup(internal_file);
}
#ifdef USE_LIBXML2
// change the xmlDocument
if( ! xdoc ){
// no .avidemuxrc file or not loaded yet
load(); // try to load it
if( ! xdoc ){ // really: no .avidemuxrc file
save(); // generate one from internal defaults and actual changes
if( xdoc )
erase_blank_nodes(xdoc->children);
}
}
if( ! xdoc ){
fprintf(stderr,"Prefs: no xml document generated ny load() nor save()\n");
}else{
xmlNodePtr p;
xmlNodePtr q;
// we assume a valid xml document, but maybe an older version
ADM_assert( xdoc->children );
p = xdoc->children; // ->avidemux (should be there)
p = goto_node_with_create(p, "lastfiles"); // ->avidemux->lastfile
q = goto_node_with_create(p, "file1"); // ->avidemux->lastfile->1
xmlNodeSetContent( q,
(xmlChar*)(opt_defs[LASTFILES_FILE1].current_val?opt_defs[LASTFILES_FILE1].current_val:""));
q = goto_node_with_create(p, "file2"); // ->avidemux->lastfile->2
xmlNodeSetContent( q,
(xmlChar*)(opt_defs[LASTFILES_FILE2].current_val?opt_defs[LASTFILES_FILE2].current_val:""));
q = goto_node_with_create(p, "file3"); // ->avidemux->lastfile->3
xmlNodeSetContent( q,
(xmlChar*)(opt_defs[LASTFILES_FILE3].current_val?opt_defs[LASTFILES_FILE3].current_val:""));
q = goto_node_with_create(p, "file4"); // ->avidemux->lastfile->4
xmlNodeSetContent( q,
(xmlChar*)(opt_defs[LASTFILES_FILE4].current_val?opt_defs[LASTFILES_FILE4].current_val:""));
save_xml_to_file();
}
#endif
#ifdef DEBUG_PREFS
PRT_LAFI("=> LASTFILES_",1,opt_defs[LASTFILES_FILE1].current_val);
PRT_LAFI("=> LASTFILES_",2,opt_defs[LASTFILES_FILE2].current_val);
PRT_LAFI("=> LASTFILES_",3,opt_defs[LASTFILES_FILE3].current_val);
PRT_LAFI("=> LASTFILES_",4,opt_defs[LASTFILES_FILE4].current_val);
#endif
delete[] internal_file;
return RC_OK;
}
uint8_t DIA_ass(ASSParams *param)
{
uint8_t r=0;
GtkWidget *dialog=create_dialog1();
gtk_register_dialog(dialog);
SPIN_SET(spinbuttonScale,font_scale);
SPIN_SET(spinbuttonSpacing,line_spacing);
SPIN_SET(spinbuttonTop,top_margin);
SPIN_SET(spinbuttonBottom,bottom_margin);
if(param->subfile)
{
int r;
char *s=(char *)(param->subfile);
gtk_editable_delete_text(GTK_EDITABLE(WID(entrySub)), 0,-1);
gtk_editable_insert_text(GTK_EDITABLE(WID(entrySub)), s, strlen(s), &r);
}
ASSOCIATE(button1,LOADSUB);
/* Upload */
int x=0,d;
while(!x)
{
d=gtk_dialog_run(GTK_DIALOG(dialog));
switch(d)
{
case LOADSUB:
{
char *name=NULL;
GUI_FileSelRead("Select ASS/SSA file",&name);
if(name)
{
int r;
gtk_editable_delete_text(GTK_EDITABLE(WID(entrySub)), 0,-1);
gtk_editable_insert_text(GTK_EDITABLE(WID(entrySub)), name, strlen(name), &r);
ADM_dealloc(name);
}
}
break;
case GTK_RESPONSE_OK:
case GTK_RESPONSE_APPLY:
{
SPIN_GET(spinbuttonScale,font_scale);
SPIN_GET(spinbuttonSpacing,line_spacing);
SPIN_GETI(spinbuttonTop,top_margin);
SPIN_GETI(spinbuttonBottom,bottom_margin);
char *n;
if(param->subfile)
{
ADM_dealloc(param->subfile);
param->subfile=NULL;
}
n=gtk_editable_get_chars(GTK_EDITABLE (WID(entrySub)), 0, -1);
printf("Name :%s\n",n);
param->subfile=(ADM_filename *)ADM_strdup(n);
r=1;
x=1;
break;
}
default:
r=0;
x=1;
break;
}
}
gtk_unregister_dialog(dialog);
gtk_widget_destroy(dialog);
return r;
}
uint8_t lavMuxer::open(const char *filename,uint32_t inbitrate, ADM_MUXER_TYPE type, aviInfo *info,
uint32_t videoExtraDataSize, uint8_t *videoExtraData, WAVHeader *audioheader,
uint32_t audioextraSize,uint8_t *audioextraData)
{
AVCodecContext *c;
_type=type;
_fps1000=info->fps1000;
switch(_type)
{
case MUXER_TS:
fmt=guess_format("mpegts", NULL, NULL);
break;
case MUXER_DVD:
fmt = guess_format("dvd", NULL, NULL);
break;
case MUXER_VCD:
fmt = guess_format("vcd", NULL, NULL);
break;
case MUXER_SVCD:
fmt = guess_format("svcd", NULL, NULL);
break;
case MUXER_MP4:
fmt = guess_format("mp4", NULL, NULL);
break;
case MUXER_PSP:
fmt = guess_format("psp", NULL, NULL);
break;
case MUXER_FLV:
fmt = guess_format("flv", NULL, NULL);
break;
case MUXER_MATROSKA:
fmt = guess_format("matroska", NULL, NULL);
break;
default:
fmt=NULL;
}
if (!fmt)
{
printf("Lav:Cannot guess format\n");
ADM_assert(0);
return 0;
}
oc = av_alloc_format_context();
if (!oc)
{
printf("Lav:Cannot allocate context\n");
return 0;
}
oc->oformat = fmt;
snprintf(oc->filename,1000,"file://%s",filename);
// Video
//________
video_st = av_new_stream(oc, 0);
if (!video_st)
{
printf("Lav: new stream failed\n");
return 0;
}
c = video_st->codec;
switch(_type)
{
case MUXER_FLV:
c->codec=new AVCodec;
memset(c->codec,0,sizeof(AVCodec));
if(fourCC::check(info->fcc,(uint8_t *)"FLV1"))
{
c->codec_id=CODEC_ID_FLV1;
c->codec->name=ADM_strdup("FLV1");
}else
{
if(fourCC::check(info->fcc,(uint8_t *)"VP6F"))
{
c->codec_id=CODEC_ID_VP6F;
c->codec->name=ADM_strdup("VP6F");
}
else
ADM_assert(0);
}
break;
case MUXER_MATROSKA:
strcpy(oc->title,"Avidemux");
strcpy(oc->author,"Avidemux");
c->sample_aspect_ratio.num=1;
c->sample_aspect_ratio.den=1;
if(isMpeg4Compatible(info->fcc))
{
c->codec_id = CODEC_ID_MPEG4;
c->has_b_frames=1; // in doubt...
}else
{
if(isH264Compatible(info->fcc))
{
c->has_b_frames=1; // in doubt...
c->codec_id = CODEC_ID_H264;
c->codec=new AVCodec;
memset(c->codec,0,sizeof(AVCodec));
c->codec->name=ADM_strdup("H264");
}
else
{
if(!ADM_4cc_to_lavcodec((const char *)&(info->fcc),&(c->codec_id)))
{
printf("[lavFormat] Cannot map this\n");
return 0;
}
}
}
if(videoExtraDataSize)
{
c->extradata=videoExtraData;
c->extradata_size= videoExtraDataSize;
}
break;
case MUXER_MP4:
case MUXER_PSP:
{
// probably a memeleak here
char *foo=ADM_strdup(filename);
strcpy(oc->title,ADM_GetFileName(foo));
strcpy(oc->author,"Avidemux");
c->sample_aspect_ratio.num=1;
c->sample_aspect_ratio.den=1;
if(isMpeg4Compatible(info->fcc))
{
c->codec_id = CODEC_ID_MPEG4;
c->has_b_frames=1; // in doubt...
}else
{
if(isH264Compatible(info->fcc))
{
c->has_b_frames=1; // in doubt...
c->codec_id = CODEC_ID_H264;
c->codec=new AVCodec;
memset(c->codec,0,sizeof(AVCodec));
c->codec->name=ADM_strdup("H264");
}
else
{
if(isDVCompatible(info->fcc))
{
c->codec_id = CODEC_ID_DVVIDEO;
}else
{
if(fourCC::check(info->fcc,(uint8_t *)"H263"))
{
c->codec_id=CODEC_ID_H263;
}else{
c->codec_id = CODEC_ID_MPEG4; // Default value
printf("Ooops, cant mux that...\n");
printf("Ooops, cant mux that...\n");
printf("Ooops, cant mux that...\n");
}
}
}
}
if(videoExtraDataSize)
{
c->extradata=videoExtraData;
c->extradata_size= videoExtraDataSize;
}
if(MUXER_PSP==_type)
{
c->rc_buffer_size=0; //8*1024*224;
c->rc_max_rate=0; //768*1000;
c->rc_min_rate=0;
c->bit_rate=768*1000;
}
else
{
c->rc_buffer_size=8*1024*224;
c->rc_max_rate=9500*1000;
c->rc_min_rate=0;
if(!inbitrate)
c->bit_rate=9000*1000;
else
c->bit_rate=inbitrate;
}
}
break;
case MUXER_TS:
c->codec_id = CODEC_ID_MPEG2VIDEO;
c->rc_buffer_size=8*1024*224;
c->rc_max_rate=9500*1000;
c->rc_min_rate=0;
if(!inbitrate)
c->bit_rate=9000*1000;
else
c->bit_rate=inbitrate;
break;
case MUXER_DVD:
c->codec_id = CODEC_ID_MPEG2VIDEO;
c->rc_buffer_size=8*1024*224;
c->rc_max_rate=9500*1000;
c->rc_min_rate=0;
if(!inbitrate)
c->bit_rate=9000*1000;
else
c->bit_rate=inbitrate;
break;
case MUXER_VCD:
c->codec_id = CODEC_ID_MPEG1VIDEO;
c->rc_buffer_size=8*1024*40;
c->rc_max_rate=1152*1000;
c->rc_min_rate=1152*1000;
c->bit_rate=1152*1000;
break;
case MUXER_SVCD:
c->codec_id = CODEC_ID_MPEG2VIDEO;
c->rc_buffer_size=8*1024*112;
c->rc_max_rate=2500*1000;
c->rc_min_rate=0*1000;
if(!inbitrate)
c->bit_rate=2040*1000;
else
c->bit_rate=inbitrate;
break;
default:
ADM_assert(0);
}
c->codec_type = CODEC_TYPE_VIDEO;
c->flags=CODEC_FLAG_QSCALE;
c->width = info->width;
c->height = info->height;
AVRational fps25=(AVRational){1001,25025};
AVRational fps24=(AVRational){1001,24000};
AVRational fps30= (AVRational){1001,30000};
AVRational fpsfree= (AVRational){1000,_fps1000};
switch(_fps1000)
{
case 25000:
{
c->time_base= fps25;
break;
}
case 23976:
if(_type==MUXER_MP4 || _type==MUXER_PSP || _type==MUXER_FLV || _type==MUXER_MATROSKA)
{
c->time_base= fps24; //(AVRational){1001,24000};
break;
}
case 29970:
c->time_base=fps30;
break;
default:
{
if(_type==MUXER_MP4 || _type==MUXER_PSP || _type==MUXER_FLV || _type==MUXER_MATROSKA)
{
c->time_base=fpsfree;// (AVRational){1000,_fps1000};
break;
}
else
{
GUI_Error_HIG(QT_TR_NOOP("Incompatible frame rate"), NULL);
return 0;
}
}
break;
}
c->gop_size=15;
c->max_b_frames=2;
c->has_b_frames=1;
// Audio
//________
if(audioheader)
{
audio_st = av_new_stream(oc, 1);
if (!audio_st)
{
printf("Lav: new stream failed\n");
return 0;
}
c = audio_st->codec;
c->frame_size=1024; //For AAC mainly, sample per frame
printf("[LavFormat] Bitrate %u\n",(audioheader->byterate*8)/1000);
_audioFq=c->sample_rate = audioheader->frequency;
#if 0
if(_type== MUXER_PSP && audioheader->encoding==WAV_AAC)
{
_audioFq=c->sample_rate = audioheader->frequency/2; //_audioFq*=2; // SBR
}
#endif
switch(audioheader->encoding)
{
case WAV_AC3: c->codec_id = CODEC_ID_AC3;break;
case WAV_MP2: c->codec_id = CODEC_ID_MP2;break;
case WAV_MP3:
#warning FIXME : Probe deeper
c->frame_size=1152;
c->codec_id = CODEC_ID_MP3;
break;
case WAV_PCM:
// One chunk is 10 ms (1/100 of fq)
c->frame_size=4;
c->codec_id = CODEC_ID_PCM_S16LE;break;
case WAV_AAC:
c->extradata=audioextraData;
c->extradata_size= audioextraSize;
c->codec_id = CODEC_ID_AAC;
break;
default:
if(_type==MUXER_MATROSKA)
{
if(ADM_WaveTag_to_lavcodec(audioheader->encoding, &(c->codec_id)))
{
if(audioextraData)
{
c->extradata=audioextraData;
c->extradata_size= audioextraSize;
}
// Put a dummy time increment
c->time_base= fps25;
break;
}
}
printf("Cant mux that ! audio\n");
printf("Cant mux that ! audio\n");
c->codec_id = CODEC_ID_MP2;
return 0;
break;
}
c->codec_type = CODEC_TYPE_AUDIO;
c->bit_rate = audioheader->byterate*8;
c->rc_buffer_size=(c->bit_rate/(2*8)); // 500 ms worth
c->channels = audioheader->channels;
_audioByterate=audioheader->byterate;
}
// /audio
//----------------------
switch(_type)
{
case MUXER_FLV:
case MUXER_PSP:
case MUXER_MP4:
case MUXER_MATROSKA:
oc->mux_rate=10080*1000; // Needed ?
break;
case MUXER_TS:
oc->mux_rate=10080*1000;
break;
case MUXER_DVD:
oc->packet_size=2048;
oc->mux_rate=10080*1000;
break;
case MUXER_VCD:
oc->packet_size=2324;
oc->mux_rate=2352 * 75 * 8;
break;
case MUXER_SVCD:
oc->packet_size=2324;
oc->mux_rate=2*2352 * 75 * 8; // ?
break;
default:
ADM_assert(0);
}
oc->preload=AV_TIME_BASE/10; // 100 ms preloading
oc->max_delay=200*1000; // 500 ms
if (av_set_parameters(oc, NULL) < 0)
{
printf("Lav: set param failed \n");
return 0;
}
if (url_fopen(&(oc->pb), filename, URL_WRONLY) < 0)
{
printf("Lav: Failed to open file :%s\n",filename);
return 0;
}
ADM_assert(av_write_header(oc)>=0);
dump_format(oc, 0, filename, 1);
printf("lavformat mpeg muxer initialized\n");
_running=1;
one=(1000*1000*1000)/_fps1000;
_curDTS=one;
return 1;
}
ADM_JSDialogFactoryHelper::ADM_JSDialogFactoryHelper(const char *title)
{
_title = ADM_strdup(title);
}
void GUI_FileSel(const char *label, SELFILE_CB cb, int rw,char **rname)
{
/* Create the selector */
GtkWidget *dialog;
char *name = NULL;
char *tmpname;
gchar *selected_filename;
uint8_t res;
if (rname)
*rname = NULL;
if (rw)
dialog = gtk_file_chooser_dialog_new ("Save", NULL, GTK_FILE_CHOOSER_ACTION_SAVE,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, NULL);
else
dialog = gtk_file_chooser_dialog_new ("Open File", NULL, GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL);
gtk_dialog_set_default_response (GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT);
gtk_dialog_set_alternative_button_order(GTK_DIALOG(dialog),
GTK_RESPONSE_ACCEPT,
GTK_RESPONSE_CANCEL,
-1);
initFileSelector();
setFilter(dialog);
gtk_window_set_title (GTK_WINDOW(dialog), label);
gtk_register_dialog(dialog);
if (rw)
res = prefs->get(LASTFILES_LASTDIR_WRITE,(char **)&tmpname);
else
res = prefs->get(LASTFILES_LASTDIR_READ,(char **)&tmpname);
if (res)
{
DIR *dir;
char *str = ADM_PathCanonize(tmpname);
ADM_PathStripName(str);
/* LASTDIR may have gone; then do nothing and use current dir instead (implied) */
if (dir = opendir(str))
{
closedir(dir);
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog),(gchar *)str);
}
delete [] str;
}
ADM_dealloc(tmpname);
if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT)
{
selected_filename = (gchar *)gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
#ifdef _WIN32
if (*(selected_filename + strlen(selected_filename) - 1) == '\\'){
#else
if (*(selected_filename + strlen(selected_filename) - 1) == '/'){
#endif
GUI_Error_HIG(QT_TR_NOOP("Cannot open directory as a file"), NULL);
}
else
{
name = ADM_strdup(selected_filename);
char *str = ADM_PathCanonize(name);
ADM_PathStripName(str);
if (rw)
prefs->set(LASTFILES_LASTDIR_WRITE, (char*)str);
else
prefs->set(LASTFILES_LASTDIR_READ, (char*)str);
delete [] str;
}
}
gtk_unregister_dialog(dialog);
gtk_widget_destroy(dialog);
// CYB 2005.02.23
if (cb)
{
#warning fixme
const char *leak=NULL;
FileSel_ReadWrite(cb, rw, name, leak);
ADM_dealloc(name);
}
else
*rname = name;
}
/* Mean:It seems it is attached to the dialog & destroyed with it
As it leads to crash if we don't recreate them each time....*/
void initFileSelector(void)
{
#define ADD_PAT(x,y) gtk_file_filter_add_pattern(x,"*."#y);
filter_avi=gtk_file_filter_new();
gtk_file_filter_set_name(filter_avi, "AVI (*.avi)");
ADD_PAT(filter_avi, avi);
ADD_PAT(filter_avi, AVI);
filter_mpeg=gtk_file_filter_new();
gtk_file_filter_set_name(filter_mpeg, "MPEG (*.m*,*.vob)");
ADD_PAT(filter_mpeg, [mM][12][Vv]);
ADD_PAT(filter_mpeg, [Mm][pP][gG]);
ADD_PAT(filter_mpeg, [Vv][Oo][Bb]);
ADD_PAT(filter_mpeg, ts);
ADD_PAT(filter_mpeg, TS);
filter_image = gtk_file_filter_new();
gtk_file_filter_set_name(filter_image, QT_TR_NOOP("Images"));
ADD_PAT(filter_image, png);
ADD_PAT(filter_image, bmp);
ADD_PAT(filter_image, jpg);
ADD_PAT(filter_image, PNG);
ADD_PAT(filter_image, BMP);
ADD_PAT(filter_image, JPG);
filter_all = gtk_file_filter_new();
gtk_file_filter_set_name(filter_all, QT_TR_NOOP("All"));
gtk_file_filter_add_pattern(filter_all, "*");
}
//**********************************************
uint8_t ADM_vob2vobsub(char *nameVob, char *nameVobSub, char *nameIfo)
{
dmx_demuxerPS *demuxer=NULL;
DIA_working *working=NULL;
MPEG_TRACK track;
FILE *indexFile=NULL;
FILE *indexSub=NULL;
uint32_t palette[16],width,height;
uint64_t abs,rel,size,pts;
int blockSize;
uint8_t *data,stream;
char *subname;
double percent;
uint32_t packetLen,usedLen,read;
OneTrack allIndex[MAX_LANGUAGE];
char language[MAX_LANGUAGE*4];
#ifdef TEST_V2V
nameIfo="d:/Crime/VTS_01_0.IFO";
nameVobSub="toto.idx";
#endif
printf("v2v: Ifo:%s Vob:%s Vsub:%s\n",nameIfo,nameVob,nameVobSub);
memset(language,0,sizeof(language));
memset(palette,0,sizeof(uint32_t)*16);
if(!vobsub_parse_ifo(nameIfo,palette,&width,&height,language))
{
GUI_Error_HIG(QT_TR_NOOP("Ifo error"),QT_TR_NOOP("Error reading ifo file, aborting."));
return 0;
}
printf("Ifo: %d x %d\n",width,height);
indexFile=fopen(nameVobSub,"wt");
if(!indexFile)
{
GUI_Error_HIG(QT_TR_NOOP("Cannot write .idx"),NULL);
return 0;
}
subname=ADM_strdup(nameVobSub);
size=strlen(subname);
subname[size-3]='s';
subname[size-2]='u';
subname[size-1]='b';
indexSub=fopen(subname,"wb");
ADM_dealloc(subname);
if(!indexSub)
{
fclose(indexFile);
GUI_Error_HIG(QT_TR_NOOP("Cannot write .sub"),NULL);
return 0;
}
for(int i=0;i<MAX_LANGUAGE;i++)
{
allIndex[i].setLang(language+i*3);
}
track.pes=0x20;
track.pid=track.pes;
demuxer=new dmx_demuxerPS(1,&track,1);
if(!demuxer->open(nameVob))
{
GUI_Error_HIG(QT_TR_NOOP("Problem opening the mpeg files"),NULL);
delete demuxer;
fclose(indexFile);
fclose(indexSub);
return 0;
}
size=demuxer->getSize();
int display=0;
dumpHeader(indexFile,0,width,height,palette);
working=new DIA_working(QT_TR_NOOP("Generating VobSub file"));
//*** Main Loop ***
uint32_t startPts=0,lastPts=0;
uint16_t hh,mm,ss,ms;
uint32_t timestamp;
while(1)
{
if(!demuxer->forceRefill(&stream)) goto _abt;
demuxer->getPos(&abs,&rel);
display++;
if(display>20)
{
working->update(abs>>10,size>>10);
display=0;
}
#ifdef TEST_V2V
//if(abs>200*1024*1024) break;
#endif
if(stream>=0x20 && stream<0x20+MAX_LANGUAGE)
{
demuxer->getPacketInfo(&data,&packetLen,&usedLen,&pts);
if(pts!=ADM_NO_PTS)
{
// Wrap around ?
if(lastPts)
{
if(pts<lastPts)
{
if(lastPts-pts>MIN_WRAP_VALUE)
{
printf("Wrapping at %u ",lastPts);
startPts+=lastPts;
timestamp=startPts/90;
ms2time(timestamp,&hh,&mm,&ss,&ms);
printf("%02d:%02d:%02d \n",hh,mm,ss);
}
}
}
lastPts=pts;
pts+=startPts;
}
#if 0
if(pts!=ADM_NO_PTS)
{
timestamp=pts/90;
ms2time(timestamp,&hh,&mm,&ss,&ms);
printf("%02d:%02d:%02d \n",hh,mm,ss);
}
#endif
blockSize=demuxer->read16i();
allIndex[stream-0x20].run(blockSize,data,packetLen,usedLen, pts) ;
}
}
/**
\fn A_openAvi
\brief Open (replace mode) a video
*/
int A_openAvi (const char *name)
{
uint8_t res;
char *longname;
uint32_t magic[4];
uint32_t id = 0;
if (playing)
return 0;
/// check if name exists
FILE *fd;
fd = ADM_fopen(name, "rb");
if (!fd)
{
if (errno == EACCES)
{
GUI_Error_HIG(QT_TRANSLATE_NOOP("adm", "Permission error"), QT_TRANSLATE_NOOP("adm", "Cannot open \"%s\"."), name);
}
if (errno == ENOENT)
{
GUI_Error_HIG(QT_TRANSLATE_NOOP("adm", "File error"), QT_TRANSLATE_NOOP("adm", "\"%s\" does not exist."), name);
}
return 0;
}
if (4 == fread(magic, 4, 4, fd))
id = R32(magic[0]);
fclose(fd);
GUI_close(); // Cleanup
// DIA_StartBusy ();
/*
** we may get a relative path by cmdline
*/
longname = ADM_PathCanonize(name);
// check if avisynth input is given
if (fourCC::check(id, (uint8_t *) "ADAP"))
res = video_body->addFile(AVS_PROXY_DUMMY_FILE);
else
res = video_body->addFile(longname);
// DIA_StopBusy ();
// forget last project file
video_body->setProjectName("");
if (res != ADM_OK) // an error occured
{
delete[] longname;
if (ADM_IGN == res)
{
return 0;
}
if (fourCC::check(id, (uint8_t *) "//AD"))
{
GUI_Error_HIG(QT_TRANSLATE_NOOP("adm", "Cannot open project using the video loader."),
QT_TRANSLATE_NOOP("adm", "Try 'File' -> 'Load/Run Project...'"));
}
else
{
GUI_Error_HIG(QT_TRANSLATE_NOOP("adm", "Could not open the file"), NULL);
}
return 0;
}
{
int i;
FILE *fd = NULL;
char magic[4];
/* check myself it is a project file (transparent detected and read
** by video_body->addFile (name);
*/
//#warning FIXME
#if 0
if ((fd = ADM_fopen(longname, "rb")))
{
if (fread(magic, 4, 1, fd) == 4)
{
/* remember a workbench file */
if (!strncmp(magic, "ADMW", 4))
{
actual_workbench_file = ADM_strdup(longname);
}
}
fclose(fd);
}
#endif
/* remember any video or workbench file to "recent" */
prefs->set_lastfile(longname);
UI_updateRecentMenu();
updateLoaded();
if (currentaudiostream)
{
uint32_t nbAudio;
audioInfo *infos = NULL;
if (video_body->getAudioStreamsInfo(admPreview::getCurrentPts() + 1, &nbAudio, &infos))
{
if (nbAudio > 1)
{ // Multiple track warn user
GUI_Info_HIG(ADM_LOG_INFO, QT_TRANSLATE_NOOP("adm", "Multiple Audio Tracks"), QT_TRANSLATE_NOOP("adm", "The file you just loaded contains several audio tracks.\n"
"Go to Audio->MainTrack to select the active one."));
}
}
if (infos) delete [] infos;
// Revert mixer to copy
//setCurrentMixerFromString("NONE");
EditableAudioTrack *ed = video_body->getDefaultEditableAudioTrack();
if (ed) ed->audioEncodingConfig.audioFilterSetMixer(CHANNEL_INVALID);
}
for (i = strlen(longname); i >= 0; i--)
{
#ifdef _WIN32
if (longname[i] == '\\' || longname[i] == '/')
#else
if (longname[i] == '/')
#endif
{
i++;
break;
}
}
UI_setTitle(longname + i);
}
delete[] longname;
return 1;
}
//______________________________________
//
// Open and get the headears/index built
// along way
//______________________________________
uint8_t OpenDMLHeader::open(const char *name)
{
uint8_t badAvi=0;
uint32_t rd;
printf("** opening OpenDML files **");
_fd=fopen(name,"rb");
if(!_fd)
{
printf("\n cannot open %s \n",name);
return 0;
}
myName=ADM_strdup(name);
#define CLR(x) memset(& x,0,sizeof( x));
CLR( _videostream);
CLR( _mainaviheader);
_isvideopresent=1;
_isaudiopresent=0;
_nbTrack=0;
riffParser *parser=new riffParser(name);
if(MKFCC('R','I','F','F')!=(rd=parser->read32()))
{
printf("Not riff\n");badAvi=1;
printf("%lx != %lx\n",rd,MKFCC('R','I','F','F'));
}
parser->read32();
if(MKFCC('A','V','I',' ')!=parser->read32())
{
printf("Not Avi\n");badAvi=1;
}
if(!badAvi)
{
walk(parser);
}
delete parser;
aprintf("Found %d tracks\n:-----------\n",_nbTrack);
// check if it looks like a correct avi
if(!_nbTrack) badAvi=1;
// if we are up to here -> good avi :)
if(badAvi)
{
printf("FAIL\n");
return 0;
}
// now read up each parts...
//____________________________
#ifdef __WIN32
#define DUMP_TRACK(i) aprintf(" at %I64u (%I64x) size : %I64u (%I64x)\n", \
_Tracks[i].strh.offset,\
_Tracks[i].strh.offset,\
_Tracks[i].strh.size,\
_Tracks[i].strh.size);
#else
#define DUMP_TRACK(i) aprintf(" at %llu (%llx) size : %llu (%llx)\n", \
_Tracks[i].strh.offset,\
_Tracks[i].strh.offset,\
_Tracks[i].strh.size,\
_Tracks[i].strh.size);
#endif
for(uint32_t i=0;i<_nbTrack;i++)
{
DUMP_TRACK(i);
}
uint32_t vidTrack=0xff;
// search wich track is the video one
// and load it to _videoheader
for(uint32_t i=0;i<_nbTrack;i++)
{
fseeko(_fd,_Tracks[i].strh.offset,SEEK_SET);
if(_Tracks[i].strh.size!=sizeof(_videostream))
{
printf("Mmm(1) we have a bogey here, size mismatch : %"LLU"\n",_Tracks[i].strh.size);
printf("expected %d\n",sizeof(_videostream));
if(_Tracks[i].strh.size<sizeof(_videostream)-8) // RECT is not mandatory
{
GUI_Error_HIG(QT_TR_NOOP("Malformed header"), NULL);
return 0;
}
printf("Trying to continue anyway\n");
}
fread(&_videostream,sizeof(_videostream),1,_fd);
#ifdef ADM_BIG_ENDIAN
Endian_AviStreamHeader(&_videostream);
#endif
if(_videostream.fccType==MKFCC('v','i','d','s'))
{
vidTrack=i;
printf("Video track is %ld\n",i);
break;
}
}
if(0xff==vidTrack)
{
printf("Could not identify video track!");
return 0;
}
// STOP HERE -> Alex <-
//return 0;
// STOP HERE -> Alex <-
// then bih stuff
int32_t extra;
// _fd=fopen(name,"rb");
fseeko(_fd,_Tracks[vidTrack].strf.offset,SEEK_SET);
extra=_Tracks[vidTrack].strf.size-sizeof(_video_bih);
if(extra<0)
{
printf("bih is not big enough (%lu/%lu)!\n",_Tracks[vidTrack].strf.size,sizeof(_video_bih));
return 0;
}
fread(&_video_bih,sizeof(_video_bih),1,_fd);
#ifdef ADM_BIG_ENDIAN
Endian_BitMapInfo(&_video_bih);
#endif
if(extra>0)
{
_videoExtraLen=extra;
_videoExtraData=new uint8_t [extra];
fread(_videoExtraData,extra,1,_fd);
}
_isvideopresent=1;
//--------------------------------------------------
// Read audio trak info, select if there is
// several
//--------------------------------------------------
// and audio track
if(_mainaviheader.dwStreams>=2)
{
// which one is the audio track, is there several ?
if(!(_nbAudioTracks=countAudioTrack()))
{
printf("Weird, there is no audio track, but more than one stream...\n");
}
else
{
uint32_t run=0,audio=0;
odmlAudioTrack *track;
_audioTracks=new odmlAudioTrack[_nbAudioTracks];
while(audio<_nbAudioTracks)
{
ADM_assert(run<_nbTrack);
track=&(_audioTracks[audio]);
fseeko(_fd,_Tracks[run].strh.offset,SEEK_SET);
if(_Tracks[run].strh.size != sizeof(_audiostream))
{
printf("Mmm(2) we have a bogey here, size mismatch : %"LLU"\n",_Tracks[run].strh.size);
printf("expected %d\n",sizeof(_audiostream));
if(_Tracks[run].strh.size<sizeof(_audiostream)-8)
{
GUI_Error_HIG(QT_TR_NOOP("Malformed header"), NULL);
return 0;
}
printf("Trying to continue anyway\n");
}
fread(track->avistream,sizeof(_audiostream),1,_fd);
#ifdef ADM_BIG_ENDIAN
Endian_AviStreamHeader(track->avistream);
#endif
if(track->avistream->fccType!=MKFCC('a','u','d','s'))
{
printf("Not an audio track!\n");
run++;
continue;
}
// now read extra stuff
fseeko(_fd,_Tracks[run].strf.offset,SEEK_SET);
extra=_Tracks[run].strf.size-sizeof(WAVHeader);
if(extra<0)
{
printf("WavHeader is not big enough (%lu/%lu)!\n",
_Tracks[run].strf.size,sizeof(WAVHeader));
return 0;
}
fread(track->wavHeader,sizeof(WAVHeader),1,_fd);
#ifdef ADM_BIG_ENDIAN
Endian_WavHeader(track->wavHeader);
#endif
if(extra>2)
{
fgetc(_fd);fgetc(_fd);
extra-=2;
track->extraDataLen=extra;
track->extraData=new uint8_t [extra];
fread(track->extraData,extra,1,_fd);
}
track->trackNum=run;
audio++;
run++;
}
}
}
// now look at the index stuff
// there could be 3 cases:
// 1- It is a openDML index, meta index + several smaller index
// 2- It is a legacy index (type 1 , most common)
// 3- It is a broken index or no index at all
//
// If it is a openDML index we will find a "indx" field in the Tracks
// Else we will find it in _regularIndex Track
// Since openDML often also have a regular index we will try open DML first
uint8_t ret=0;
Dump();
// take the size of riff header and actual file size
uint64_t riffSize;
fseeko(_fd,0,SEEK_END);
_fileSize=ftello(_fd);
fseeko(_fd,0,SEEK_SET);
read32();
riffSize=(uint64_t )read32();
// 1st case, we have an avi < 4 Gb
// potentially avi type 1
#if 0
if((_fileSize<4*1024*1024*1024LL)&&
// if riff size is ~ fileSize try regular index
(abs(riffSize-_fileSize)<1024*1024))
#endif
#define HAS(x) if(x) printf(#x" : yes\n"); else printf(#x" : no\n");
// If there is no openDML index
HAS( _regularIndex.offset);
HAS( _Tracks[vidTrack].indx.offset);
if(!ret && _regularIndex.offset &&!_Tracks[vidTrack].indx.offset)
// try regular avi if a idx1 field is there (avi index)
ret=indexRegular(vidTrack);
if (!ret && _Tracks[vidTrack].indx.offset) // Try openDML if a index field is there (openDML)
ret=indexODML(vidTrack);
if(!ret)
{
printf("Could not index it properly...\n");
return 0;
}
if(!_nbAudioTracks)
{
_isaudiopresent=0;
}
else
{
// build audio stream
odmlAudioTrack *track;
// Check it is not a weird DV file
if(fourCC::check(_video_bih.biCompression,(uint8_t *)"dvsd"))
{
for(int i=0;i<_nbAudioTracks;i++)
{
track=&(_audioTracks[i]);
WAVHeader *hdr= track->wavHeader;
if(!hdr->frequency)
{
printf("Fixing audio track to be PCM\n");
hdr->frequency=48000;
//hdr->channels=2;
hdr->byterate=48000*hdr->channels*2;
hdr->blockalign=2*hdr->channels;
}
}
}
for(int i=0;i<_nbAudioTracks;i++)
{
track=&(_audioTracks[i]);
_audioTracks[i].track= new AVDMAviAudioStream(track->index,
track->nbChunks,
myName,
track->wavHeader,
0,
track->extraDataLen,track->extraData);
}
}
if (!_video_bih.biCompression && fourCC::check(_videostream.fccHandler,(uint8_t*)"DIB "))
{
// flip video
uint8_t *extraData = new uint8_t[_videoExtraLen + 9];
memcpy(extraData, _videoExtraData, _videoExtraLen);
memcpy(extraData + _videoExtraLen, "BottomUp", 9);
delete [] _videoExtraData;
_videoExtraLen += 9;
_videoExtraData = extraData;
_videostream.fccHandler = _video_bih.biCompression = fourCC::get((uint8_t*)"DIB ");
}
else
_videostream.fccHandler=_video_bih.biCompression;
printf("\nOpenDML file successfully read..\n");
return ret;
}
uint8_t DIA_v2v(char **vobname, char **ifoname,char **vobsubname)
{
uint8_t ret=0;
char *tmp=NULL,*tmp2=NULL,*tmp3=NULL;
GtkWidget *dialog;
dialog=create_dialog1();
gtk_register_dialog(dialog);
gtk_dialog_add_action_widget (GTK_DIALOG (dialog), WID(buttonVob),actionVOB);
gtk_dialog_add_action_widget (GTK_DIALOG (dialog), WID(buttonIfo),actionIFO);
gtk_dialog_add_action_widget (GTK_DIALOG (dialog), WID(buttonVobSub),actionVOBSUB);
#define ENTRY_SET(x,y) {gtk_write_entry_string(WID(x),*y);}
ENTRY_SET(entryIfo,ifoname);
ENTRY_SET(entryVob,vobname);
ENTRY_SET(entryVobSub,vobsubname);
while(1)
{
switch(gtk_dialog_run(GTK_DIALOG(dialog)))
{
case actionVOB:
{
int r;
GUI_FileSelRead(_("Select Vob file to scan"),&tmp);
if(!tmp) continue;
gtk_editable_delete_text(GTK_EDITABLE(WID(entryVob)), 0,-1);
gtk_editable_insert_text(GTK_EDITABLE(WID(entryVob)), tmp, strlen(tmp), &r);
ADM_dealloc(tmp);
}
break;
case actionIFO:
{
int r;
GUI_FileSelRead(_("Select ifo file to use"),&tmp);
if(!tmp) continue;
gtk_editable_delete_text(GTK_EDITABLE(WID(entryIfo)), 0,-1);
gtk_editable_insert_text(GTK_EDITABLE(WID(entryIfo)), tmp, strlen(tmp), &r);
ADM_dealloc(tmp);
}
break;
case actionVOBSUB:
{
int r;
GUI_FileSelWrite(_("Select vobsub to write"),&tmp);
if(!tmp) continue;
gtk_editable_delete_text(GTK_EDITABLE(WID(entryVobSub)), 0,-1);
gtk_editable_insert_text(GTK_EDITABLE(WID(entryVobSub)), tmp, strlen(tmp), &r);
ADM_dealloc(tmp);
}
break;
break;
case GTK_RESPONSE_OK:
{
tmp=gtk_editable_get_chars(GTK_EDITABLE (WID(entryVob)), 0, -1);
if(!tmp || !*tmp)
{
GUI_Error_HIG(_("Invalid vobname"),_("Please select or enter a valid vob name"));
continue;
}
tmp2=gtk_editable_get_chars(GTK_EDITABLE (WID(entryIfo)), 0, -1);
if(!tmp2 || !*tmp2)
{
GUI_Error_HIG(_("Invalid ifo"),_("Please select or enter a valid ifo file"));
continue;
}
tmp3=gtk_editable_get_chars(GTK_EDITABLE (WID(entryVobSub)), 0, -1);
if(!tmp3 || !*tmp3 )
{
GUI_Error_HIG(_("Invalid vobsubname"),_("Please select or enter a valid vobsub file"));
continue;
}
if(*vobname) ADM_dealloc(*vobname);
if(*ifoname) ADM_dealloc(*ifoname);
if(*vobsubname) ADM_dealloc(*vobsubname);
*vobname=*ifoname=*vobsubname=NULL;
*vobname=ADM_strdup(tmp);
*ifoname=ADM_strdup(tmp2);
*vobsubname=(char *)ADM_alloc(strlen(tmp3)+5); //ADM_strdup(tmp3);
strcpy(*vobsubname,tmp3);
if(tmp3[strlen(tmp3)-1]!='x') strcat(*vobsubname,".idx");
ret=1;
}
default: goto _nxt;
}
}
_nxt:
gtk_unregister_dialog(dialog);
gtk_widget_destroy(dialog);
return ret;
}
ADM_scriptDFToggleHelper::ADM_scriptDFToggleHelper(const char *title)
{
_title = ADM_strdup(title);
_value = 0;
}
/**
\fn DIA_Preferences
\brief Handle preference dialog
*/
uint8_t DIA_Preferences(void)
{
uint32_t olddevice,newdevice;
uint32_t use_odml=0;
uint32_t render;
uint32_t useTray=0;
uint32_t useMaster=0;
uint32_t useAutoIndex=0;
uint32_t useSwap=0;
uint32_t useNuv=0;
uint32_t lavcThreads=0;
uint32_t encodePriority=2;
uint32_t indexPriority=2;
uint32_t playbackPriority=0;
uint32_t downmix;
uint32_t mpeg_no_limit=0;
uint32_t msglevel=2;
uint32_t mixer=0;
char *alsaDevice=NULL;
uint32_t autovbr=0;
uint32_t autoindex=0;
uint32_t autounpack=0;
uint32_t alternate_mp3_tag=1;
uint32_t pp_type=3;
uint32_t pp_value=5;
uint32_t hzd,vzd,dring;
uint32_t capsMMX,capsMMXEXT,caps3DNOW,caps3DNOWEXT,capsSSE,capsSSE2,capsSSE3,capsSSSE3,capsAll;
uint32_t useGlobalGlyph=0;
char *globalGlyphName=NULL;
olddevice=newdevice=AVDM_getCurrentDevice();
// Default pp
if(!prefs->get(DEFAULT_POSTPROC_TYPE,&pp_type)) pp_type=3;
if(!prefs->get(DEFAULT_POSTPROC_VALUE,&pp_value)) pp_value=3;
#define DOME(x,y) y=!!(pp_type & x)
DOME(1,hzd);
DOME(2,vzd);
DOME(4,dring);
// Cpu caps
#define CPU_CAPS(x) if(CpuCaps::myCpuMask & ADM_CPUCAP_##x) caps##x=1; else caps##x=0;
if(CpuCaps::myCpuMask==ADM_CPUCAP_ALL) capsAll=1; else capsAll=0;
CPU_CAPS(MMX);
CPU_CAPS(MMXEXT);
CPU_CAPS(3DNOW);
CPU_CAPS(3DNOWEXT);
CPU_CAPS(SSE);
CPU_CAPS(SSE2);
CPU_CAPS(SSE3);
CPU_CAPS(SSSE3);
// Alsa
#ifdef ALSA_SUPPORT
if( prefs->get(DEVICE_AUDIO_ALSA_DEVICE, &alsaDevice) != RC_OK )
alsaDevice = ADM_strdup("plughw:0,0");
#endif
// autovbr
prefs->get(FEATURE_AUTO_BUILDMAP,&autovbr);
// autoindex
prefs->get(FEATURE_AUTO_REBUILDINDEX,&autoindex);
// Global glyph
prefs->get(FEATURE_GLOBAL_GLYPH_ACTIVE,&useGlobalGlyph);
prefs->get(FEATURE_GLOBAL_GLYPH_NAME,&globalGlyphName);
// autoindex
prefs->get(FEATURE_AUTO_UNPACK,&autounpack);
// Alternate mp3 tag (haali)
prefs->get(FEATURE_ALTERNATE_MP3_TAG,&alternate_mp3_tag);
// Video renderer
if(prefs->get(DEVICE_VIDEODEVICE,&render)!=RC_OK)
{
render=(uint32_t)RENDER_GTK;
}
// SysTray
if(!prefs->get(FEATURE_USE_SYSTRAY,&useTray))
useTray=0;
// Accept mpeg for DVD when fq!=48 kHz
if(!prefs->get(FEATURE_MPEG_NO_LIMIT,&mpeg_no_limit)) mpeg_no_limit=0;
// Multithreads
prefs->get(FEATURE_THREADING_LAVC, &lavcThreads);
// Encoding priority
if(!prefs->get(PRIORITY_ENCODING, &encodePriority))
encodePriority=2;
// Indexing / unpacking priority
if(!prefs->get(PRIORITY_INDEXING, &indexPriority))
indexPriority=2;
// Playback priority
if(!prefs->get(PRIORITY_PLAYBACK, &playbackPriority))
playbackPriority=0;
// Open DML (Gmv)
if(!prefs->get(FEATURE_USE_ODML, &use_odml))
use_odml=0;
#if defined(ALSA_SUPPORT) || defined (OSS_SUPPORT)
// Master or PCM for audio
if(!prefs->get(FEATURE_AUDIOBAR_USES_MASTER, &useMaster))
useMaster=0;
#endif
// Autoindex files
if(!prefs->get(FEATURE_TRYAUTOIDX, &useAutoIndex))
useAutoIndex=0;
// SWAP A&B if A>B
if(!prefs->get(FEATURE_SWAP_IF_A_GREATER_THAN_B, &useSwap))
useSwap=0;
// No nuv sync
if(!prefs->get(FEATURE_DISABLE_NUV_RESYNC, &useNuv))
useNuv=0;
// Get level of message verbosity
prefs->get(MESSAGE_LEVEL,&msglevel);
// Downmix default
if(prefs->get(DOWNMIXING_PROLOGIC,&downmix)!=RC_OK)
{
downmix=0;
}
olddevice=newdevice=AVDM_getCurrentDevice();
// Audio device
/************************ Build diaelems ****************************************/
diaElemToggle useSysTray(&useTray,QT_TR_NOOP("_Use systray while encoding"));
diaElemToggle allowAnyMpeg(&mpeg_no_limit,QT_TR_NOOP("_Accept non-standard audio frequency for DVD"));
diaElemToggle openDml(&use_odml,QT_TR_NOOP("Create _OpenDML files"));
diaElemToggle autoIndex(&useAutoIndex,QT_TR_NOOP("Automatically _index MPEG files"));
diaElemToggle autoSwap(&useSwap,QT_TR_NOOP("Automatically _swap A and B if A>B"));
diaElemToggle nuvAudio(&useNuv,QT_TR_NOOP("_Disable NUV audio sync"));
diaElemToggle togAutoVbr(&autovbr,QT_TR_NOOP("Automatically _build VBR map"));
diaElemToggle togAutoIndex(&autoindex,QT_TR_NOOP("Automatically _rebuild index"));
diaElemToggle togAutoUnpack(&autounpack,QT_TR_NOOP("Automatically remove _packed bitstream"));
diaElemFrame frameSimd(QT_TR_NOOP("SIMD"));
diaElemToggle capsToggleAll(&capsAll,QT_TR_NOOP("Enable all SIMD"));
diaElemToggle capsToggleMMX(&capsMMX, QT_TR_NOOP("Enable MMX"));
diaElemToggle capsToggleMMXEXT(&capsMMXEXT, QT_TR_NOOP("Enable MMXEXT"));
diaElemToggle capsToggle3DNOW(&caps3DNOW, QT_TR_NOOP("Enable 3DNOW"));
diaElemToggle capsToggle3DNOWEXT(&caps3DNOWEXT, QT_TR_NOOP("Enable 3DNOWEXT"));
diaElemToggle capsToggleSSE(&capsSSE, QT_TR_NOOP("Enable SSE"));
diaElemToggle capsToggleSSE2(&capsSSE2, QT_TR_NOOP("Enable SSE2"));
diaElemToggle capsToggleSSE3(&capsSSE3, QT_TR_NOOP("Enable SSE3"));
diaElemToggle capsToggleSSSE3(&capsSSSE3, QT_TR_NOOP("Enable SSSE3"));
capsToggleAll.link(0, &capsToggleMMX);
capsToggleAll.link(0, &capsToggleMMXEXT);
capsToggleAll.link(0, &capsToggle3DNOW);
capsToggleAll.link(0, &capsToggle3DNOWEXT);
capsToggleAll.link(0, &capsToggleSSE);
capsToggleAll.link(0, &capsToggleSSE2);
capsToggleAll.link(0, &capsToggleSSE3);
capsToggleAll.link(0, &capsToggleSSSE3);
frameSimd.swallow(&capsToggleAll);
frameSimd.swallow(&capsToggleMMX);
frameSimd.swallow(&capsToggleMMXEXT);
frameSimd.swallow(&capsToggle3DNOW);
frameSimd.swallow(&capsToggle3DNOWEXT);
frameSimd.swallow(&capsToggleSSE);
frameSimd.swallow(&capsToggleSSE2);
frameSimd.swallow(&capsToggleSSE3);
frameSimd.swallow(&capsToggleSSSE3);
diaElemThreadCount lavcThreadCount(&lavcThreads, QT_TR_NOOP("_lavc threads:"));
diaElemFrame frameThread(QT_TR_NOOP("Multi-threading"));
frameThread.swallow(&lavcThreadCount);
diaMenuEntry priorityEntries[] = {
{0, QT_TR_NOOP("High"),NULL}
,{1, QT_TR_NOOP("Above normal"),NULL}
,{2, QT_TR_NOOP("Normal"),NULL}
,{3, QT_TR_NOOP("Below normal"),NULL}
,{4, QT_TR_NOOP("Low"),NULL}
};
diaElemMenu menuEncodePriority(&encodePriority,QT_TR_NOOP("_Encoding priority:"), sizeof(priorityEntries)/sizeof(diaMenuEntry), priorityEntries,"");
diaElemMenu menuIndexPriority(&indexPriority,QT_TR_NOOP("_Indexing/unpacking priority:"), sizeof(priorityEntries)/sizeof(diaMenuEntry), priorityEntries,"");
diaElemMenu menuPlaybackPriority(&playbackPriority,QT_TR_NOOP("_Playback priority:"), sizeof(priorityEntries)/sizeof(diaMenuEntry), priorityEntries,"");
diaElemFrame framePriority(QT_TR_NOOP("Prioritisation"));
framePriority.swallow(&menuEncodePriority);
framePriority.swallow(&menuIndexPriority);
framePriority.swallow(&menuPlaybackPriority);
diaElemToggle togTagMp3(&alternate_mp3_tag,QT_TR_NOOP("_Use alternative tag for MP3 in .mp4"));
diaMenuEntry videoMode[]={
{RENDER_GTK, getNativeRendererDesc(), NULL}
#if ADM_UI_TYPE_BUILD == ADM_UI_QT4 && defined(USE_OPENGL)
,{RENDER_QT_OPENGL, QT_TR_NOOP("Qt (OpenGL)"), NULL}
#endif
#ifdef USE_XV
,{RENDER_XV, QT_TR_NOOP("XVideo (best)"),NULL}
#endif
#ifdef USE_SDL
#ifdef __WIN32
,{RENDER_SDL, QT_TR_NOOP("SDL (MS Windows GDI)"),NULL}
,{RENDER_DIRECTX, QT_TR_NOOP("SDL (MS Windows DirectX)"),NULL}
#else
,{RENDER_SDL, QT_TR_NOOP("SDL (good)"),NULL}
#endif
#endif
};
diaElemMenu menuVideoMode(&render,QT_TR_NOOP("Video _display:"), sizeof(videoMode)/sizeof(diaMenuEntry),videoMode,"");
diaMenuEntry msgEntries[]={
{0, QT_TR_NOOP("No alerts"),NULL}
,{1, QT_TR_NOOP("Display only error alerts"),NULL}
,{2, QT_TR_NOOP("Display all alerts"),NULL}
};
diaElemMenu menuMessage(&msglevel,QT_TR_NOOP("_Message level:"), sizeof(msgEntries)/sizeof(diaMenuEntry),msgEntries,"");
#if defined(ALSA_SUPPORT) || defined (OSS_SUPPORT)
diaMenuEntry volumeEntries[]={
{0, QT_TR_NOOP("PCM"),NULL}
,{1, QT_TR_NOOP("Master"),NULL}};
diaElemMenu menuVolume(&useMaster,QT_TR_NOOP("_Volume control:"), sizeof(volumeEntries)/sizeof(diaMenuEntry),volumeEntries,"");
#endif
diaMenuEntry mixerEntries[]={
{0, QT_TR_NOOP("No downmixing"),NULL}
,{1, QT_TR_NOOP("Stereo"),NULL}
,{2, QT_TR_NOOP("Pro Logic"),NULL}
,{3, QT_TR_NOOP("Pro Logic II"),NULL}
};
diaElemMenu menuMixer(&downmix,QT_TR_NOOP("_Local playback downmixing:"), sizeof(mixerEntries)/sizeof(diaMenuEntry),mixerEntries,"");
//*********** AV_
//***AV
uint32_t nbAudioDevice=ADM_av_getNbDevices();
diaMenuEntryDynamic *audioDeviceItems[nbAudioDevice+1];
audioDeviceItems[0]=new diaMenuEntryDynamic(0,"Dummy","Dummy");
for(int i=0;i<nbAudioDevice;i++)
{
const char *name;
uint32_t major,minor,patch;
ADM_av_getDeviceInfo(i, &name, &major,&minor,&patch);
audioDeviceItems[i+1]=new diaMenuEntryDynamic(i+1,name,name);
}
diaElemMenuDynamic menuAudio(&newdevice,QT_TR_NOOP("_AudioDevice"), nbAudioDevice+1,
audioDeviceItems,NULL);
// default Post proc
diaElemToggle fhzd(&hzd,QT_TR_NOOP("_Horizontal deblocking"));
diaElemToggle fvzd(&vzd,QT_TR_NOOP("_Vertical deblocking"));
diaElemToggle fdring(&dring,QT_TR_NOOP("De_ringing"));
diaElemUInteger postProcStrength(&pp_value,QT_TR_NOOP("_Strength:"),0,5);
diaElemFrame framePP(QT_TR_NOOP("Default Postprocessing"));
framePP.swallow(&fhzd);
framePP.swallow(&fvzd);
framePP.swallow(&fdring);
framePP.swallow(&postProcStrength);
diaElemToggle togGlobalGlyph(&useGlobalGlyph, QT_TR_NOOP("Use _Global GlyphSet"));
diaElemFile entryGLyphPath(0,&globalGlyphName,QT_TR_NOOP("Gl_yphSet:"), NULL, QT_TR_NOOP("Select GlyphSet file"));
togGlobalGlyph.link(1, &entryGLyphPath);
/* User Interface */
diaElem *diaUser[]={&useSysTray,&menuMessage};
diaElemTabs tabUser(QT_TR_NOOP("User Interface"),2,diaUser);
/* Automation */
diaElem *diaAuto[]={&autoSwap,&togAutoVbr,&togAutoIndex,&togAutoUnpack,&autoIndex,};
diaElemTabs tabAuto(QT_TR_NOOP("Automation"),5,diaAuto);
/* Input */
diaElem *diaInput[]={&nuvAudio};
diaElemTabs tabInput(QT_TR_NOOP("Input"),1,(diaElem **)diaInput);
/* Output */
diaElem *diaOutput[]={&openDml,&allowAnyMpeg,&togTagMp3};
diaElemTabs tabOutput(QT_TR_NOOP("Output"),3,(diaElem **)diaOutput);
/* Audio */
diaElem *diaAudio[]={&menuMixer,&menuAudio};
diaElemTabs tabAudio(QT_TR_NOOP("Audio"),2,(diaElem **)diaAudio);
/* Video */
diaElem *diaVideo[]={&menuVideoMode,&framePP};
diaElemTabs tabVideo(QT_TR_NOOP("Video"),2,(diaElem **)diaVideo);
/* CPU tab */
diaElem *diaCpu[]={&frameSimd};
diaElemTabs tabCpu(QT_TR_NOOP("CPU"),1,(diaElem **)diaCpu);
/* Threading tab */
diaElem *diaThreading[]={&frameThread, &framePriority};
diaElemTabs tabThreading(QT_TR_NOOP("Threading"),2,(diaElem **)diaThreading);
/* Global Glyph tab */
diaElem *diaGlyph[]={&togGlobalGlyph,&entryGLyphPath};
diaElemTabs tabGlyph(QT_TR_NOOP("Global GlyphSet"),2,(diaElem **)diaGlyph);
// SET
diaElemTabs *tabs[]={&tabUser,&tabAuto,&tabInput,&tabOutput,&tabAudio,&tabVideo,&tabCpu,&tabThreading,&tabGlyph};
if( diaFactoryRunTabs(QT_TR_NOOP("Preferences"),9,tabs))
{
// cpu caps
if(capsAll)
{
CpuCaps::myCpuMask=ADM_CPUCAP_ALL;
}else
{
CpuCaps::myCpuMask=0;
#undef CPU_CAPS
#define CPU_CAPS(x) if(caps##x) CpuCaps::myCpuMask|= ADM_CPUCAP_##x;
CPU_CAPS(MMX);
CPU_CAPS(MMXEXT);
CPU_CAPS(3DNOW);
CPU_CAPS(3DNOWEXT);
CPU_CAPS(SSE);
CPU_CAPS(SSE2);
CPU_CAPS(SSE3);
CPU_CAPS(SSSE3);
}
prefs->set(FEATURE_CPU_CAPS,CpuCaps::myCpuMask);
// Glyphs
prefs->set(FEATURE_GLOBAL_GLYPH_ACTIVE,useGlobalGlyph);
prefs->set(FEATURE_GLOBAL_GLYPH_NAME,globalGlyphName);
// Postproc
#undef DOME
#define DOME(x,y) if(y) pp_type |=x;
pp_type=0;
DOME(1,hzd);
DOME(2,vzd);
DOME(4,dring);
prefs->set(DEFAULT_POSTPROC_TYPE,pp_type);
prefs->set(DEFAULT_POSTPROC_VALUE,pp_value);
//
prefs->set(FEATURE_AUTO_UNPACK,autounpack);
// autovbr
prefs->set(FEATURE_AUTO_BUILDMAP,autovbr);
// autoindex
prefs->set(FEATURE_AUTO_REBUILDINDEX,autoindex);
// Alsa
#ifdef ALSA_SUPPORT
if(alsaDevice)
{
prefs->set(DEVICE_AUDIO_ALSA_DEVICE, alsaDevice);
ADM_dealloc(alsaDevice);
alsaDevice=NULL;
}
#endif
// Device
if(olddevice!=newdevice)
{
AVDM_switch((AUDIO_DEVICE)newdevice);
}
// Downmixing (default)
prefs->set(DOWNMIXING_PROLOGIC,downmix);
#if defined(ALSA_SUPPORT) || defined (OSS_SUPPORT)
// Master or PCM
prefs->set(FEATURE_AUDIOBAR_USES_MASTER, useMaster);
#endif
// allow non std audio fq for dvd
prefs->set(FEATURE_MPEG_NO_LIMIT, mpeg_no_limit);
// Video render
prefs->set(DEVICE_VIDEODEVICE,render);
// Odml
prefs->set(FEATURE_USE_ODML, use_odml);
// number of threads
prefs->set(FEATURE_THREADING_LAVC, lavcThreads);
// Encoding priority
prefs->set(PRIORITY_ENCODING, encodePriority);
// Indexing / unpacking priority
prefs->set(PRIORITY_INDEXING, indexPriority);
// Playback priority
prefs->set(PRIORITY_PLAYBACK, playbackPriority);
// Auto index mpeg
prefs->set(FEATURE_TRYAUTOIDX, useAutoIndex);
// Auto swap A/B
prefs->set(FEATURE_SWAP_IF_A_GREATER_THAN_B, useSwap);
//
prefs->set(MESSAGE_LEVEL,msglevel);
// Disable nuv sync
prefs->set(FEATURE_DISABLE_NUV_RESYNC, useNuv);
// Use tray while encoding
prefs->set(FEATURE_USE_SYSTRAY,useTray);
// Alternate mp3 tag (haali)
prefs->set(FEATURE_ALTERNATE_MP3_TAG,alternate_mp3_tag);
#if defined(__WIN32) && defined(USE_SDL)
// Initialise SDL again as driver may have changed
initSdl(render);
#endif
}
for(int i=0;i<nbAudioDevice+1;i++)
{
delete audioDeviceItems[i];
}
ADM_dealloc(globalGlyphName);
return 1;
}
void loadTranslator(void)
{
char *lang=NULL;
bool autoSelect=true;
if(prefs->get(DEFAULT_LANGUAGE,&lang))
{
if(lang && strlen(lang)>0 && strcmp(lang,"auto"))
autoSelect=false;
}
if(autoSelect)
{
ADM_info("Using system language\n");
lang=ADM_strdup(QLocale::system().name().toUtf8().constData());
}else
{
ADM_info("Language forced \n");
}
ADM_info("Initializing language %s\n",lang);
#if QT_VERSION < QT_VERSION_CHECK(5,0,0)
std::string flavor="/qt4";
#else
std::string flavor="/qt5";
#endif
std::string partialPath=std::string(flavor)+std::string("/i18n/");
#ifdef __APPLE__
QString appdir = QCoreApplication::applicationDirPath() + "/../share/avidemux6/"+QString(partialPath.c_str());
#elif defined(_WIN32)
QString appdir = QCoreApplication::applicationDirPath() + QString(partialPath.c_str());
#else
QString appdir = ADM_getInstallRelativePath("share","avidemux6",partialPath.c_str());
#endif
QString languageFile=QString(lang);
int nbLoaded=0;
nbLoaded+=loadTranslation(&qtTranslator, appdir + "qt_" + languageFile);
nbLoaded+=loadTranslation(&avidemuxTranslator, appdir + "avidemux_" + languageFile);
translatorLoaded = true;
if(!nbLoaded) // Nothing to translate..
return;
ADM_info("Updating translations...\n");
// Re-translate existing map (to take care of global strings already allocated)
if(!map)
map = new QMap<QString, char*>;
QMapIterator<QString, char*> mapIterator(*map);
while (mapIterator.hasNext())
{
mapIterator.next();
QByteArray translatedMessage = QApplication::translate("", mapIterator.key().toLatin1().constData()).toUtf8();
char *buffer = mapIterator.value();
int copyLength = translatedMessage.length() + 1;
if (copyLength > MAX_UNLOADED_MSG_LENGTH + 1)
{
copyLength = MAX_UNLOADED_MSG_LENGTH;
buffer[MAX_UNLOADED_MSG_LENGTH] = '\0';
}
memcpy(buffer, translatedMessage.constData(), copyLength);
}
ADM_info("[Locale] Test: &Edit -> %s\n\n", HIDE_STRING_FROM_QT("MainWindow", "&Edit").toUtf8().data());
}
uint8_t lavMuxer::open(const char *filename,uint32_t inbitrate, ADM_MUXER_TYPE type, aviInfo *info,uint32_t videoExtraDataSize,
uint8_t *videoExtraData, WAVHeader *audioheader,uint32_t audioextraSize,uint8_t *audioextraData)
{
AVCodecContext *c;
_type=type;
_fps1000=info->fps1000;
switch(_type)
{
case MUXER_TS:
fmt=guess_format("mpegts", NULL, NULL);
break;
case MUXER_DVD:
fmt = guess_format("dvd", NULL, NULL);
break;
case MUXER_VCD:
fmt = guess_format("vcd", NULL, NULL);
break;
case MUXER_SVCD:
fmt = guess_format("svcd", NULL, NULL);
break;
case MUXER_MP4:
fmt = guess_format("mp4", NULL, NULL);
break;
case MUXER_PSP:
fmt = guess_format("psp", NULL, NULL);
break;
default:
fmt=NULL;
}
if (!fmt)
{
printf("Lav:Cannot guess format\n");
return 0;
}
oc = av_alloc_format_context();
if (!oc)
{
printf("Lav:Cannot allocate context\n");
return 0;
}
oc->oformat = fmt;
snprintf(oc->filename,1000,"file://%s",filename);
// Video
//________
video_st = av_new_stream(oc, 0);
if (!video_st)
{
printf("Lav: new stream failed\n");
return 0;
}
c = video_st->codec;
switch(_type)
{
case MUXER_MP4:
if(isMpeg4Compatible(info->fcc))
{
c->codec_id = CODEC_ID_MPEG4;
c->has_b_frames=1; // in doubt...
}else
{
if(isH264Compatible(info->fcc))
{
c->has_b_frames=1; // in doubt...
c->codec_id = CODEC_ID_H264;
c->codec=new AVCodec;
memset(c->codec,0,sizeof(AVCodec));
c->codec->name=ADM_strdup("H264");
}
else
{
c->codec_id = CODEC_ID_MPEG4; // Default value
printf("Ooops, cant mux that...\n");
printf("Ooops, cant mux that...\n");
printf("Ooops, cant mux that...\n");
//return 0;
}
}
if(videoExtraDataSize)
{
c->extradata=videoExtraData;
c->extradata_size= videoExtraDataSize;
}
c->rc_buffer_size=8*1024*224;
c->rc_max_rate=9500*1000;
c->rc_min_rate=0;
if(!inbitrate)
c->bit_rate=9000*1000;
else
c->bit_rate=inbitrate;
break;
case MUXER_TS:
c->codec_id = CODEC_ID_MPEG2VIDEO;
c->rc_buffer_size=8*1024*224;
c->rc_max_rate=9500*1000;
c->rc_min_rate=0;
if(!inbitrate)
c->bit_rate=9000*1000;
else
c->bit_rate=inbitrate;
break;
case MUXER_DVD:
c->codec_id = CODEC_ID_MPEG2VIDEO;
c->rc_buffer_size=8*1024*224;
c->rc_max_rate=9500*1000;
c->rc_min_rate=0;
if(!inbitrate)
c->bit_rate=9000*1000;
else
c->bit_rate=inbitrate;
break;
case MUXER_VCD:
c->codec_id = CODEC_ID_MPEG1VIDEO;
c->rc_buffer_size=8*1024*40;
c->rc_max_rate=1152*1000;
c->rc_min_rate=1152*1000;
c->bit_rate=1152*1000;
break;
case MUXER_SVCD:
c->codec_id = CODEC_ID_MPEG2VIDEO;
c->rc_buffer_size=8*1024*112;
c->rc_max_rate=2500*1000;
c->rc_min_rate=0*1000;
if(!inbitrate)
c->bit_rate=2040*1000;
else
c->bit_rate=inbitrate;
break;
default:
ADM_assert(0);
}
c->codec_type = CODEC_TYPE_VIDEO;
c->flags=CODEC_FLAG_QSCALE;
c->width = info->width;
c->height = info->height;
switch(_fps1000)
{
case 25000:
c->time_base= (AVRational){1001,25025};
//c->frame_rate = 25025;
//c->frame_rate_base = 1001;
break;
case 23976:
/*
c->frame_rate = 24000;
c->frame_rate_base = 1001;
break;
*/
if(_type==MUXER_MP4)
{
c->time_base= (AVRational){1001,24000};
break;
}
case 29970:
c->time_base= (AVRational){1001,30000};
//c->frame_rate = 30000;
//c->frame_rate_base = 1001;
break;
default:
if(_type==MUXER_MP4)
{
c->time_base= (AVRational){1000,_fps1000};
break;
}
else
{
GUI_Error_HIG(_("Incompatible frame rate"), NULL);
return 0;
}
}
c->gop_size=15;
c->max_b_frames=2;
c->has_b_frames=1;
// Audio
//________
if(audioheader)
{
audio_st = av_new_stream(oc, 1);
if (!audio_st)
{
printf("Lav: new stream failed\n");
return 0;
}
c = audio_st->codec;
c->frame_size=1024; //For AAC mainly, sample per frame
switch(audioheader->encoding)
{
case WAV_AC3: c->codec_id = CODEC_ID_AC3;break;
case WAV_MP2: c->codec_id = CODEC_ID_MP2;break;
case WAV_MP3:
#warning FIXME : Probe deeper
c->frame_size=1152;
c->codec_id = CODEC_ID_MP3;
break;
case WAV_PCM:
// One chunk is 10 ms (1/100 of fq)
c->frame_size=4;
c->codec_id = CODEC_ID_PCM_S16LE;break;
case WAV_AAC:
c->extradata=audioextraData;
c->extradata_size= audioextraSize;
c->codec_id = CODEC_ID_AAC;
break;
default:
printf("Cant mux that ! audio\n");
printf("Cant mux that ! audio\n");
c->codec_id = CODEC_ID_MP2;
return 0;
break;
}
c->codec_type = CODEC_TYPE_AUDIO;
c->bit_rate = audioheader->byterate*8;
c->rc_buffer_size=(c->bit_rate/(2*8)); // 500 ms worth
_audioFq=c->sample_rate = audioheader->frequency;
c->channels = audioheader->channels;
_audioByterate=audioheader->byterate;
}
// /audio
//----------------------
switch(_type)
{
case MUXER_MP4:
oc->mux_rate=10080*1000; // Needed ?
break;
case MUXER_TS:
oc->mux_rate=10080*1000;
break;
case MUXER_DVD:
oc->packet_size=2048;
oc->mux_rate=10080*1000;
break;
case MUXER_VCD:
oc->packet_size=2324;
oc->mux_rate=2352 * 75 * 8;
break;
case MUXER_SVCD:
oc->packet_size=2324;
oc->mux_rate=2*2352 * 75 * 8; // ?
break;
default:
ADM_assert(0);
}
oc->preload=AV_TIME_BASE/10; // 100 ms preloading
oc->max_delay=200*1000; // 500 ms
if (av_set_parameters(oc, NULL) < 0)
{
printf("Lav: set param failed \n");
return 0;
}
if (url_fopen(&(oc->pb), filename, URL_WRONLY) < 0)
{
printf("Lav: Failed to open file :%s\n",filename);
return 0;
}
av_write_header(oc);
dump_format(oc, 0, filename, 1);
printf("lavformat mpeg muxer initialized\n");
_running=1;
one=(1000*1000*1000)/_fps1000;
_curDTS=one;
return 1;
}
avsfilter::avsfilter(ADM_coreVideoFilter *in,
CONFcouple *couples) : ADM_coreVideoFilter(in,couples)
{
ADM_assert(in);
tmp_buf = NULL;
in=in;
DEBUG_PRINTF("Create AVSfilter(%X), AVDMGenericVideoStream %X\n", this, in);
wine_loader = NULL;
// param = new (avsfilter_config);
DEBUG_PRINTF("avsfilter : preconstructor info : frameIncrement %lu totalDuration %llu\n",
info.frameIncrement, info.totalDuration);
memcpy(&info, previousFilter->getInfo(),sizeof(info));
DEBUG_PRINTF("avsfilter : constructor info : frameIncrement %lu totalDuration %llu\n",
info.frameIncrement, info.totalDuration);
// info.encoding=1;
//vidCache = NULL;
#define AVSFILTER_CONFIG_NAME "/avsfilter.config2"
int sz_prefs_name = strlen (ADM_getUserPluginSettingsDir()) + sizeof(AVSFILTER_CONFIG_NAME) + 1;
prefs_name = new char [sz_prefs_name];
snprintf(prefs_name, sz_prefs_name, "%s%s", ADM_getUserPluginSettingsDir(), AVSFILTER_CONFIG_NAME);
if (!couples || !ADM_paramLoad(couples,
avsfilter_config_param,
¶m))
{
if (!avsfilter_config_jdeserialize(prefs_name, avsfilter_config_param, ¶m))
{
param.wine_app = ADM_strdup("wine");
param.avs_script = ADM_strdup("test.avs");;
param.avs_loader = ADM_strdup(AVS_WINE_BINARY_PATH"/avsload.exe");
param.pipe_timeout = 10;
param.script_ctime = 0;
param.script_mtime = 0;
}
}
DEBUG_PRINTF("avsfilter : constructor info #2: frameIncrement %lu totalDuration %llu\n",
info.frameIncrement, info.totalDuration);
DEBUG_PRINTF("avsfilter : wine_app %s avsloader %s avsscript %s\n",
param.wine_app, param.avs_loader, param.avs_script);
if (!SetParameters(¶m))
{
DEBUG_PRINTF_RED("avsfilter : SetParameters return false\n");
DEBUG_PRINTF("avsfilter : info after error: frameIncrement %lu totalDuration %llu\n",
info.frameIncrement, info.totalDuration);
return;
}
DEBUG_PRINTF("avsfilter : constructor info #3: frameIncrement %lu totalDuration %llu\n",
info.frameIncrement, info.totalDuration);
#ifndef NOCOMPILE26
if (prefs->get(FILTERS_AVSFILTER_WINE_APP, &tmp_str) == RC_OK &&
strlen(tmp_str) > 0)
{
_param->wine_app = (ADM_filename*)ADM_strdup (tmp_str);
DEBUG_PRINTF("avsfilter : wine_app from config is %s\n", _param->wine_app);
ADM_dealloc(tmp_str);
}
if (prefs->get(FILTERS_AVSFILTER_AVS_SCRIPT, &tmp_str) == RC_OK &&
strlen(tmp_str) > 0)
{
_param->avs_script = (ADM_filename*)ADM_strdup (tmp_str);
DEBUG_PRINTF("avsfilter : avsscript from config is %s\n", _param->avs_script);
ADM_dealloc(tmp_str);
}
if (prefs->get(FILTERS_AVSFILTER_AVS_LOADER, &tmp_str) == RC_OK &&
strlen(tmp_str) > 0)
{
_param->avs_loader = (ADM_filename*)ADM_strdup (tmp_str);
DEBUG_PRINTF("avsfilter : avsloader from config is %s\n", _param->avs_loader);
ADM_dealloc(tmp_str);
}
prefs->get(FILTERS_AVSFILTER_PIPE_TIMEOUT, &_param->pipe_timeout);
struct stat st;
if (_param->avs_script)
if (stat((char*)_param->avs_script, &st) != 0)
{
DEBUG_PRINTF_RED("avsfilter : cannot stat script file\n");
return;
}
else
{
_param->script_mtime = st.st_mtime; // store timestamp
_param->script_ctime = st.st_ctime;
}
}