/**
\fn A_jog
\brief Handle jogshuttle widget
*/
void A_jog(void)
{
int32_t r;
uint32_t a;
uint32_t slip;
static int jog=0;
if(jog) return;
jog++;
while(r=A_jogRead())
{
a=abs(r);
printf("%d \n",r);
if(a<JOG_THRESH1) slip=JOG_THRESH1_PERIOD;
else if(a<JOG_THRESH2) slip=JOG_THRESH2_PERIOD;
else slip=JOG_THRESH3_PERIOD;
if(r>0) GUI_NextKeyFrame();
else GUI_PreviousKeyFrame();
UI_purge();
for(int i=0;i<slip/REFRESH;i++)
{
UI_purge();
ADM_usleep(REFRESH);
UI_purge();
}
}
jog--;
}
/**
\brief Resize the window
*/
void UI_updateDrawWindowSize(void *win,uint32_t w,uint32_t h)
{
if(displayW == w && displayH == h && rgbDataBuffer)
return;
if(rgbDataBuffer)
delete[] rgbDataBuffer;
rgbDataBuffer = new uint8_t[w * h * 4]; // 32 bits / color
displayW = w;
displayH = h;
hostFrame->setMinimumSize(displayW, displayH);
videoWindow->setMinimumSize(displayW, displayH);
hostFrame->resize(displayW, displayH);
videoWindow->resize(displayW, displayH);
UI_purge();
QuiMainWindows->adjustSize();
UI_purge();
// Trolltech need to get their act together. Resizing doesn't work well or the same on all platforms.
#if defined(__APPLE__)
// Hack required for Mac to resize properly. adjustSize() just doesn't cut the mustard.
QuiMainWindows->resize(QuiMainWindows->width() + 1, QuiMainWindows->height() + 1);
#else
// resizing doesn't work unless called twice on Windows and Linux.
QuiMainWindows->adjustSize();
#endif
UI_purge();
printf("[RDR] Resizing to %u x %u\n", displayW, displayH);
}
uint8_t ADM_ocrDrawFull(void *d,uint8_t *data)
{
drawing=data;;
UI_purge();
gui_draw();
UI_purge();
return 1;
}
/**
\fn GUI_PlayAvi
\brief MainLoop for internal movie playback
*/
void GUI_PlayAvi(void)
{
uint32_t framelen,flags;
uint32_t max,err;
uint64_t oldTimeFrame;
aviInfo info;
renderZoom oldZoom=admPreview::getCurrentZoom();
video_body->getVideoInfo(&info);
// check we got everything...
if (!video_body->getNbSegment()) return;
if (playing)
{
stop_req = 1;
return;
}
oldTimeFrame=admPreview::getCurrentPts();
uint32_t priorityLevel;
#ifndef __HAIKU__
originalPriority = getpriority(PRIO_PROCESS, 0);
prefs->get(PRIORITY_PLAYBACK,&priorityLevel);
setpriority(PRIO_PROCESS, 0, ADM_getNiceValue(priorityLevel));
#endif
stop_req = 0;
playing = 1;
admPreview::deferDisplay(true);
//admPreview::samePicture();
GUIPlayback *playLoop=new GUIPlayback;
playLoop->initialize();
playLoop->run();
delete playLoop;
playing = 0;
admPreview::deferDisplay(false);
// Resize the output window to original size...
ADM_info("Restoring display.\n");
admPreview::setMainDimension(info.width,info.height,oldZoom);
// If we are processing the video, the current time
// might not be matching a source video time => PROBLEM
// Go back to the beginning to be on safe ground
// In copy mode, we can keep the current position
if(getPreviewMode()!=ADM_PREVIEW_NONE)
admPreview::seekToTime(oldTimeFrame);
UI_purge();
admPreview::samePicture();
GUI_setCurrentFrameAndTime();
UI_purge();
}
/**
\brief Resize the window
*/
void UI_updateDrawWindowSize(void *win,uint32_t w,uint32_t h)
{
GUI_gtk_grow_off(0);
gtk_widget_set_usize((GtkWidget *)win, w, h);
UI_purge();
GUI_gtk_grow_off(1);
lastW=w;
lastH=h;
printf("[GTK] Changing size to %u %u\n",w,h);
UI_purge();
}
/**
\brief Resize the window
*/
void UI_updateDrawWindowSize(void *win,uint32_t w,uint32_t h)
{
gtk_window_set_resizable(GTK_WINDOW(guiRootWindow), FALSE);
gtk_widget_set_size_request((GtkWidget *)win, w, h);
UI_purge();
gtk_window_set_resizable(GTK_WINDOW(guiRootWindow), TRUE);
lastW=w;
lastH=h;
printf("[GTK] Changing size to %u %u\n",w,h);
UI_purge();
}
uint8_t DIA_working::update(uint32_t percent)
{
GtkWidget *dialog;
uint32_t elapsed;
char b[300];
UI_purge();
if(!_priv) return 1;
dialog=(GtkWidget *)_priv;
if(!percent) return 0;
if(percent==lastper) return 0;
aprintf("DIA_working::update(%lu) called\n", percent);
elapsed=_clock.getElapsedMS();
if(!elapsed) return 0;
lastper=percent;
//
// 100/totalMS=percent/elapsed
// totalM=100*elapsed/percent
double f;
f=100.;
f*=elapsed;
f/=percent;
f-=elapsed;
f/=1000;
uint32_t sectogo=(uint32_t)floor(f);
int mm,ss;
mm=sectogo/60;
ss=sectogo%60;
sprintf(b, " %d m %d s left", mm,ss);
aprintf("DIA_working::update(%lu): new time left: %s\n"
"\tf=%f sectogo=%lu\n", percent,b,f,sectogo);
gtk_label_set_text(GTK_LABEL(lookup_widget(dialog,"label_time")), b);
double p;
p=percent;
p=p/100.;
gtk_progress_set_percentage(GTK_PROGRESS(lookup_widget(dialog,"progressbar1")),(gfloat)p);
UI_purge();
return 0;
}
//_____________________________________________________________
int GUI_GoToFrame(uint32_t frame)
{
uint32_t flags;
if (playing)
return 0;
if (!avifileinfo)
return 0;
if(frame>=avifileinfo->nb_frames) return 0;
if( !GUI_getFrame(frame ,&flags))
{
GUI_Error_HIG(QT_TR_NOOP("Decompressing error"),QT_TR_NOOP( "Cannot decode the frame."));
return 0;
}
curframe = frame;
admPreview::update( curframe) ;
update_status_bar();
UI_purge();
return 1;
}
void GUI_PreviousKeyFrame(void)
{
uint32_t f;
uint32_t flags;
if (playing)
return;
f=curframe;
if (avifileinfo)
{
if(!video_body->getPKFrame(&f)&&curframe)
{
return;
}
else
{
curframe=f;
if( !GUI_getFrame(curframe,&flags))
{
GUI_Error_HIG(QT_TR_NOOP("Decompressing error"),QT_TR_NOOP( "Cannot decode keyframe."));
}
admPreview::update( curframe) ;
update_status_bar();
UI_purge();
}
}
};
/**
* \fn update
* @param percent
* @return true if processing should be stopped
*/
bool DIA_processingQt::update(uint32_t frame,uint64_t currentProcess)
{
UI_purge();
if(_stopRequest) return true;
if(!frame) return false;
_currentFrames+=frame;
uint32_t elapsed=_clock.getElapsedMS();
if(elapsed<_nextUpdate)
{
return false;
}
_clock.reset();
_nextUpdate=REFRESH_RATE_IN_MS;
if(_first)
{
_first=false;
for(int i=0;i<PROC_NB_SLOTS;i++)
_slots[i]=_currentFrames;
}
_slots[_slotIndex]=_currentFrames;
_slotIndex%=PROC_NB_SLOTS;
// compute time left
double percent=((double)(currentProcess))/((double)_totalToProcess);
double dElapsed=_totalTime.getElapsedMS(); // in dElapsed time, we have made percent percent
double totalTimeNeeded=dElapsed/percent;
double remaining=totalTimeNeeded-dElapsed;
if(remaining<0) remaining=1;
std::string r;
ADM_durationToString(remaining, r);
QString qRemaining=QString(r.c_str());
percent=100.*percent;
aprintf("Percent=%d,cur=%d,tot=%d\n",(int)percent,_lastFrames,_totalFrame);
aprintf("time %llx/ total time %llx\n",currentProcess,_totalToProcess);
if(percent>100.) percent=99.9;
if(percent<0.1) percent=0.1;
_lastFrames+=_currentFrames;
_currentFrames=0;
int avg=0;
for(int i=0;i<PROC_NB_SLOTS;i++)
avg+=_slots[i];
avg/=PROC_NB_SLOTS;
if(ui)
{
ui->labelImages->setText( QString::number(_lastFrames));
ui->labelTimeLeft->setText(qRemaining);
ui->progressBar->setValue((int)percent);
ui->labelSpeed->setText(QString::number(avg)+QString(" fps"));
}
return false;
}
void GUI_NextFrame(uint32_t frameCount)
{
// uint8_t *ptr;
uint32_t flags;
if (playing)
return;
if( avifileinfo && curframe + frameCount >= avifileinfo->nb_frames )
return;
if (avifileinfo)
{
uint32_t newframe = curframe + frameCount;
if( !GUI_getFrame(newframe,&flags))
{
GUI_Error_HIG(QT_TR_NOOP("Decompressing error"),QT_TR_NOOP( "Cannot decode next frame."));
}
else
{
curframe = newframe;
admPreview::update( curframe) ;
update_status_bar();
UI_purge();
}
}
}
//_____________________________________________________________
void GUI_NextKeyFrame(void)
{
uint32_t f;
uint32_t flags;
if (playing)
return;
f=curframe;
if (avifileinfo)
{
if(!video_body->getNKFrame(&f))
//if( !GUI_getFrameNKF(&f ,rdr_decomp_buffer))
{
// GUI_Error_HIG("Decompressing error", NULL);
}
else
{
curframe=f;
if( !GUI_getFrame(curframe,&flags))
{
GUI_Error_HIG(QT_TR_NOOP("Decompressing error"),QT_TR_NOOP( "Cannot decode keyframe."));
}
admPreview::update( curframe) ;
update_status_bar();
UI_purge();
}
}
}
///
/// Create main window and bind to it
///
uint8_t initGUI( void )
{
uint8_t ret=0;
uint32_t w,h;
// create top window
guiRootWindow=create_mainWindow();
if(!guiRootWindow) return 0;
#ifdef ENABLE_WINDOW_SIZING_HACK
do_tmpwin_hack();
#endif
gtk_register_dialog(guiRootWindow);
// and seek global sub entity
ret= bindGUI();
if(ret) gtk_widget_show(guiRootWindow);
UI_purge();
// Set it as always low level
//gtk_window_set_keep_below(GTK_WINDOW(guiRootWindow), 1);
renderInit();
GUI_initCursor( );
UI_getPhysicalScreenSize(guiRootWindow, &w, &h);
printf("The screen seems to be %u x %u px\n",w,h);
GUI_gtk_grow_off(1);
#ifdef USE_JOG
physical_jog_shuttle = &(PhysicalJogShuttle::getInstance());
physical_jog_shuttle->registerCBs (NULL, jogButton, jogDial, jogRing);
#endif
return ret;
}
//_____________________________________________________________
int GUI_GoToFrame(uint32_t frame)
{
uint32_t flags;
if (playing)
return 0;
if (!avifileinfo)
return 0;
if( !GUI_getFrame(frame ,rdr_decomp_buffer,&flags))
{
GUI_Alert("Decompressing Error GF");
return 0;
}
curframe = frame;
renderUpdateImage(rdr_decomp_buffer->data);
if(mode_preview)
editorUpdatePreview( curframe);
update_status_bar(rdr_decomp_buffer);
UI_purge();
return 1;
}
void GUI_NextFrame(void)
{
// uint8_t *ptr;
uint32_t flags;
if (playing)
return;
if( avifileinfo && curframe + 1 == avifileinfo->nb_frames )
return;
if (avifileinfo)
{
if( !GUI_getFrame(curframe + 1,rdr_decomp_buffer,&flags))
{
GUI_Alert("Decompressing Error NF");
}
else
{
curframe++;
if(mode_preview)
editorUpdatePreview( curframe) ;
renderUpdateImage(rdr_decomp_buffer->data);
update_status_bar(rdr_decomp_buffer);
UI_purge();
}
}
}
void DIA_StartBusy( void )
{
UI_BusyCursor();
UI_purge();
}
DIA_progressIndexing::DIA_progressIndexing(const char *name)
{
dialog=new Ui_indexingDialog(qtLastRegisteredDialog(), name);
qtRegisterDialog(dialog);
clock.reset();
aborted=0;
_nextUpdate=0;
dialog->show();
UI_purge();
}
void GUI_encoderStart( void )
{
window=create_dialog1();
tobedestroyed=0;
gtk_widget_show(window);
timestart=getTime(0);
lastTime=timestart;
lastFrame=0;
fps_average=0;
UI_purge();
UI_iconify();
}
void on_work_abort(GtkObject * object, gpointer user_data)
{
DIA_working *dial;
GtkWidget *dialog;
UNUSED_ARG(object);
dial=(DIA_working *)user_data;
dialog=(GtkWidget *)dial->_priv;
gtk_widget_destroy(dialog);
dial->_priv=NULL;
UI_purge();
};
void DIA_StartBusyDialog( void )
{
busy=create_dialog1();
gtk_signal_connect(GTK_OBJECT(busy), "delete_event",
GTK_SIGNAL_FUNC(on_destroy_abort), (void *) NULL);
gtk_register_dialog(busy);
gtk_widget_show(busy);
UI_purge();
ADM_usleep(500);
}
//----------------------------------------
uint8_t renderResize(uint32_t w, uint32_t h,renderZoom newzoom)
{
int mul,xx,yy;
if(screenBuffer)
{
delete [] screenBuffer;
screenBuffer=NULL;
}
if(resized)
{
delete resized;
resized=NULL;
}
if(resizer)
{
delete resizer;
resizer=NULL;
}
zoom=newzoom;
switch(zoom)
{
case ZOOM_1_4: mul=1;break;
case ZOOM_1_2: mul=2;break;
case ZOOM_1_1: mul=4;break;
case ZOOM_2: mul=8;break;
case ZOOM_4: mul=16;break;
default : ADM_assert(0);
}
xx=(w*mul+3)/4;
yy=(h*mul+3)/4;
if(xx&1) xx++;
if(yy&1) yy++;
screenBuffer=new uint8_t[xx*yy*4];
if(zoom!=ZOOM_1_1)
{
resizer=new ADM_MplayerResize(w,h,xx,yy);
resized=new ADMImage(xx,yy);
}
updateWindowSize( draw,xx,yy);
UI_purge();
return 1;
}
uint8_t DIA_workingQt4::update(uint32_t percent)
{
#define GUI_UPDATE_RATE 1000
UI_purge();
if(!_priv) return 1;
if(!percent) return 0;
if(percent==lastper)
{
return 0;
}
elapsed=_clock.getElapsedMS();
if(elapsed<_nextUpdate)
{
return 0;
}
_nextUpdate=elapsed+1000;
lastper=percent;
uint32_t hh,mm,ss,mms;
char string[9];
ms2time(elapsed,&hh,&mm,&ss,&mms);
sprintf(string,"%02d:%02d:%02d",hh,mm,ss);
workWindow *wind=(workWindow *)_priv; ADM_assert(wind);
if(percent>=1)
{
double totalTime=(100*elapsed)/percent;
double remaining=totalTime-elapsed;
if(remaining<0)
remaining=0;
uint32_t remainingMs=(uint32_t)remaining;
wind->ui->labelTimeLeft->setText(ms2timedisplay(remainingMs));
}
wind->ui->labelElapsed->setText(string);
wind->ui->progressBar->setValue(percent);
return 0;
}
uint8_t DIA_working::update(uint32_t cur, uint32_t total)
{
double d,n;
uint32_t percent;
UI_purge();
if(!_priv) return 1;
if(!total) return 0;
d=total;
n=cur;
n=n*100.;
n=n/d;
percent=(uint32_t )floor(n);
return update(percent);
}
void DIA_encodingBase::reset(void)
{
_lastFrameCount=0;
_currentFrameCount=0;
_currentDts=0;
_lastDts=0;
_totalSize=0;
_audioSize=0;
_videoSize=0;
_nextUpdate=GUI_UPDATE_RATE;
_lastClock=0;
_fps_average=0;
_remainingTimeUs=0;
sampleIndex=0;
memset(samples,0,sizeof(samples));
clock.reset();
UI_purge();
}
//----------------------------------------
uint8_t renderDisplayResize(uint32_t w, uint32_t h,renderZoom zoom)
{
bool create=false;
enableDraw=false;
ADM_info("Render to %"PRIu32"x%"PRIu32" zoom=%d\n",w,h,zoom);
if(!renderer) create=true;
else
{
if(w!=phyW || h!=phyH) create=true;
}
if(create)
{
if(renderer)
{
renderer->stop();
delete renderer;
}
renderer=NULL;
phyW=w;
phyH=h;
lastZoom=zoom;
spawnRenderer();
}else
{
if(lastZoom!=zoom) renderer->changeZoom(zoom);
}
lastZoom=zoom;
int mul;
switch(zoom)
{
case ZOOM_1_4: mul=1;break;
case ZOOM_1_2: mul=2;break;
case ZOOM_1_1: mul=4;break;
case ZOOM_2: mul=8;break;
case ZOOM_4: mul=16;break;
default : ADM_assert(0);break;
}
MUI_updateDrawWindowSize(draw,(w*mul)/4,(h*mul)/4);
renderCompleteRedrawRequest();
UI_purge();
return 1;
}
uint8_t DIA_progressIndexing::update(uint32_t done,uint32_t total, uint32_t nbImage, uint32_t hh, uint32_t mm, uint32_t ss)
{
char string[512];
double f;
UI_purge();
sprintf(string,"%02d:%02d:%02d",hh,mm,ss);
gtk_label_set_text(GTK_LABEL(WID(labelTime)),string);
sprintf(string,"%0lu",nbImage);
gtk_label_set_text(GTK_LABEL(WID(labelNbImage)),string);
f=done;
f/=total;
gtk_progress_set_percentage(GTK_PROGRESS(WID(progressbar1)),(gfloat)f);
return 1;
}
void DIA_working :: postCtor( void )
{
GtkWidget *dialog;
dialog=(GtkWidget *)_priv;
gtk_window_set_modal(GTK_WINDOW(dialog), 1);
gtk_signal_connect(GTK_OBJECT(lookup_widget(dialog,"closebutton1")), "clicked",
GTK_SIGNAL_FUNC(on_work_abort), (void *) this);
// somehow prevent the window from being erased..
gtk_signal_connect(GTK_OBJECT(dialog), "delete_event",
GTK_SIGNAL_FUNC(on_destroy_abort), (void *) this);
gtk_widget_show(dialog);
UI_purge();
lastper=0;
}
uint8_t DIA_progressIndexing::update(uint32_t done,uint32_t total, uint32_t nbImage, uint32_t hh, uint32_t mm, uint32_t ss)
{
uint32_t tim;
#define GUI_UPDATE_RATE 1000
tim=clock.getElapsedMS();
if(tim>_nextUpdate)
{
char string[256];
double f;
uint32_t tom,zhh,zmm,zss,zmms;
_nextUpdate=tim+GUI_UPDATE_RATE;
sprintf(string,"%02d:%02d:%02d",hh,mm,ss);
dialog->setTime(string);
sprintf(string,QT_TRANSLATE_NOOP("indexing","# Images :%0"PRIu32),nbImage);
dialog->setImage(string);
f=done;
f/=total;
dialog->setPercent(f);
/* compute ETL */
// Do a simple relation between % and time
// Elapsed time =total time*percent
if(f<0.01) return 1;
f=tim/f;
// Tom is total time
tom=(uint32_t)floor(f);
if(tim>tom) return 1;
tom=tom-tim;
ms2time(tom,&zhh,&zmm,&zss,&zmms);
sprintf(string,QT_TRANSLATE_NOOP("indexing","Time Left :%02d:%02d:%02d"),zhh,zmm,zss);
dialog->setETA(string);
UI_purge();
}
return 1;
}
uint8_t DIA_progressIndexing::update(uint32_t done,uint32_t total, uint32_t nbImage, uint32_t hh, uint32_t mm, uint32_t ss)
{
uint32_t tim;
#define GUI_UPDATE_RATE 1000
tim=clock.getElapsedMS();
if(tim>_nextUpdate)
{
char string[256];
double f;
uint32_t tom,zhh,zmm,zss;
_nextUpdate=tim+GUI_UPDATE_RATE;
sprintf(string,"%02d:%02d:%02d",hh,mm,ss);
gtk_label_set_text(GTK_LABEL(WID(labelTime)),string);
sprintf(string,"%0lu",nbImage);
gtk_label_set_text(GTK_LABEL(WID(labelNbImage)),string);
f=done;
f/=total;
gtk_progress_set_percentage(GTK_PROGRESS(WID(progressbar1)),(gfloat)f);
/* compute ETL */
// Do a simple relation between % and time
// Elapsed time =total time*percent
if(f<0.01) return 1;
f=tim/f;
// Tom is total time
tom=(uint32_t)floor(f);
if(tim>tom) return 1;
tom=tom-tim;
ms2time(tom,&zhh,&zmm,&zss);
sprintf(string,"%02d:%02d:%02d",zhh,zmm,zss);
gtk_label_set_text(GTK_LABEL(WID(label6)),string);
UI_purge();
}
return 1;
}
//_____________________________________________________________
void GUI_NextKeyFrame(void)
{
uint32_t f;
uint32_t flags;
if (playing)
return;
f=curframe;
if (avifileinfo)
{
if(!video_body->getNKFrame(&f))
//if( !GUI_getFrameNKF(&f ,rdr_decomp_buffer))
{
// GUI_Alert("Decompressing Error");
}
else
{
curframe=f;
if( !GUI_getFrame(curframe,rdr_decomp_buffer,&flags))
{
GUI_Alert("Decompressing Error NKF");
}
renderUpdateImage(rdr_decomp_buffer->data);
if(mode_preview)
editorUpdatePreview( curframe) ;
update_status_bar(rdr_decomp_buffer);
UI_purge();
}
}
}
