uint32_t getPicSize(void)
{
uint32_t size;
AVDMGenericVideoStream *last;
last=getLastVideoFilter();
size=last->getInfo()->width*last->getInfo()->height;
return size;
}
uint32_t getPicSize(void)
{
#warning FIXME
return 720*576;
#if 0
uint32_t size;
AVDMGenericVideoStream *last;
last=getLastVideoFilter();
size=last->getInfo()->width*last->getInfo()->height;
return size;
#endif
}
/**
\fn filtermainWindow::partial( bool b)
\brief Partialize one filter
*/
void filtermainWindow::partial( bool b)
{
printf("partial\n");
QListWidgetItem *item=activeList->currentItem();
if(!item)
{
printf("No selection\n");
return;
}
int itag=item->type();
ADM_assert(itag>ACTIVE_FILTER_BASE);
itag-=ACTIVE_FILTER_BASE;
/* Filter 0 is the decoder ...*/
printf("Rank : %d\n",itag);
ADM_assert(itag);
AVDMGenericVideoStream *replace;
CONFcouple *conf;
conf = videofilters[itag].conf;
if (videofilters[itag].tag == VF_PARTIAL_FILTER) // cannot recurse
{
GUI_Error_HIG (QT_TR_NOOP("The filter is already partial"), NULL);
return;
}
replace =new ADMVideoPartial (videofilters[itag - 1].
filter,
videofilters[itag].tag,
conf);
if(replace->configure (videofilters[itag - 1].filter))
{
delete videofilters[itag].filter;
if (conf) delete conf;
videofilters[itag].filter = replace;
replace->getCoupledConf (&conf);
videofilters[itag].conf = conf;
videofilters[itag].tag = VF_PARTIAL_FILTER;
getFirstVideoFilter ();
buildActiveFilterList ();
setSelected(itag);
}
else delete replace;
}
uint8_t ADMVideoFlipV::getFrameNumberNoAlloc(uint32_t frame,
uint32_t *len,
ADMImage *data,
uint32_t *flags)
{
if (frame>= _info.nb_frames)
return 0;
// read uncompressed frame
if (!_in->getFrameNumberNoAlloc(frame, len, _uncompressed, flags))
return 0;
uint8_t *in, *out;
uint32_t stride=_info.width;
uint32_t h=_info.height;
uint32_t page, qpage;
page=stride*h;
qpage=page>>2;
in=YPLANE(_uncompressed);
out=YPLANE(data)+(h-1)*stride;
// flip y
for (uint32_t y=h; y>0; y--)
{
memcpy(out,in,stride);
in+=stride;
out-=stride;
}
// Flip U & V
stride>>=1;
in=UPLANE(_uncompressed);
out=UPLANE(data)+qpage-stride;
// flip u
for (uint32_t y=h>>1; y>0; y--)
{
memcpy(out,in,stride);
in+=stride;
out-=stride;
}
in=VPLANE(_uncompressed);
out=VPLANE(data)+qpage-stride;
// flip u
for (uint32_t y=h>>1; y>0; y--)
{
memcpy(out,in,stride);
in+=stride;
out-=stride;
}
data->copyInfo(_uncompressed);
return 1;
}
uint8_t DIA_particle (AVDMGenericVideoStream *in,
ADMVideoParticle * particlep,
PARTICLE_PARAM * param,
const MenuMapping * menu_mapping,
uint32_t menu_mapping_count)
{
// Allocate space for preview video
uint32_t width = in->getInfo()->width;
uint32_t height = in->getInfo()->height;
dialog = create_particle_dialog();
gtk_dialog_set_alternative_button_order(GTK_DIALOG(dialog),
GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL,
-1);
gtk_register_dialog (dialog);
gtk_window_set_title (GTK_WINDOW (dialog),
QT_TR_NOOP("Particle Analysis Configuration"));
gtk_widget_show (dialog);
// Fix up a bunch of things that Glade can't do. This is less efficient
// than just editing the Glade output, but it's not that big a deal and
// doing it this way makes it MUCH easier to use Glade to tweak the layout
// later.
// actually, nothing to fix up in this one. But if there ever is, this is
// the place to do it...
flyParticle * myDialog
= new flyParticle (width, height, in,
WID(previewVideo), WID(previewSlider),
GTK_DIALOG(dialog), particlep, param,
menu_mapping, menu_mapping_count);
g_signal_connect (GTK_OBJECT (WID(previewVideo)), "configure-event",
GTK_SIGNAL_FUNC (preview_video_configured),
gpointer (myDialog));
myDialog->upload();
myDialog->sliderChanged();
g_signal_connect (GTK_OBJECT(WID(outputFileBrowseButton)), "clicked",
GTK_SIGNAL_FUNC(browse_button_clicked),
gpointer(myDialog));
// update things when settings are changed
#define CNX(_widg,_signame) \
g_signal_connect (GTK_OBJECT(WID(_widg)), _signame, \
GTK_SIGNAL_FUNC(gui_update), gpointer(myDialog));
CNX (minAreaSpinButton, "value_changed");
CNX (maxAreaSpinButton, "value_changed");
CNX (leftCropSpinButton, "value_changed");
CNX (rightCropSpinButton, "value_changed");
CNX (topCropSpinButton, "value_changed");
CNX (bottomCropSpinButton, "value_changed");
g_signal_connect (GTK_OBJECT(WID(previewSlider)), "value_changed",
GTK_SIGNAL_FUNC(frame_changed), gpointer(myDialog));
g_signal_connect (GTK_OBJECT(WID(previewVideo)), "expose_event",
GTK_SIGNAL_FUNC(gui_draw), gpointer(myDialog));
g_signal_connect (GTK_OBJECT(WID(previewVideo)), "button_press_event",
GTK_SIGNAL_FUNC(previewButtonEvent),
gpointer(myDialog));
#if 0
g_signal_connect (GTK_OBJECT(WID(previewVideo)), "motion_notify_event",
GTK_SIGNAL_FUNC(previewMotionEvent),
gpointer(myDialog));
#endif
GtkWidget * previewOutputMenu = WID(previewOutputMenu);
uint32_t filter_count;
FILTER * filters = getCurrentVideoFilterList (&filter_count);
int32_t active = -1;
// The " + (active < 0)" below is a bit of a hack. We know that in
// on_action() in gui_filtermanager.cpp, case A_ADD, the new filter-to-be
// is added to the filter list without incrementing nb_active_filter yet.
// So if we get to the end of the list and haven't yet found the filter
// that we're configuring, we know it's a new one and therefore that it is
// one past the apparent end of the list. It's not a clean solution, but
// it seems like the cleanEST solution.
for (uint32_t i = 0; i < filter_count + (active < 0); i++)
{
const char * name
= (i == 0) ? "(input)" : filterGetNameFromTag (filters [i].tag);
bool free_name = false;
FILTER * filter = filters + i;
AVDMGenericVideoStream * source = filter->filter;
uint32_t w = source->getInfo()->width;
uint32_t h = source->getInfo()->height;
if (w != width || h != height)
{
name = g_strconcat ("XX ", name, " XX", NULL);
free_name = true;
}
printf ("filter [%d] = %s (%d) @ %p; %dx%d\n",
i, name, filter->tag, source, w, h);
gtk_combo_box_append_text (GTK_COMBO_BOX (previewOutputMenu), name);
if (filter->filter == myDialog->getSource())
{
gtk_combo_box_set_active (GTK_COMBO_BOX (previewOutputMenu), i);
printf ("\tfilter [%d] is being configured now\n", i);
active = i;
}
if (free_name)
g_free (const_cast <char *> (name));
}
ADM_assert (active >= 0);
myDialog->this_filter_index = active;
g_signal_connect (GTK_OBJECT(previewOutputMenu), "changed",
GTK_SIGNAL_FUNC(previewOutputMenuChange),
gpointer(myDialog));
uint8_t ret = 0;
int response = gtk_dialog_run(GTK_DIALOG(dialog));
if (response == GTK_RESPONSE_OK)
{
myDialog->download();
myDialog->pushParam();
ret = 1;
}
else
myDialog->restoreParam();
gtk_unregister_dialog(dialog);
gtk_widget_destroy(dialog);
delete myDialog;
return ret;
}
//
// One of the button of the main dialog was pressed
// Retrieve also the associated filter and handle
// the action
//______________________________________________________
void on_action (gui_act action)
{
uint32_t action_parameter;
VF_FILTERS tag = VF_INVALID;
action_parameter = 0;
if (nb_active_filter > 1)
if (getSelectionNumber(nb_active_filter - 1,
WID(treeview0),
stores[0],
&action_parameter))
action_parameter++;
switch (action)
{
case A_ADD:
tag = getFilterFromSelection();
if (tag == VF_INVALID) break;
CONFcouple *coup;
videofilters[nb_active_filter].filter =
filterCreateFromTag (tag, NULL, videofilters[nb_active_filter - 1].filter);
videofilters[nb_active_filter].tag = tag;
if(!videofilters[nb_active_filter].filter->
configure (videofilters[nb_active_filter - 1].filter))
{
delete videofilters[nb_active_filter].filter;
break;
}
videofilters[nb_active_filter].filter->getCoupledConf (&coup);
videofilters[nb_active_filter].conf = coup;
nb_active_filter++;
updateFilterList ();
setSelectionNumber(nb_active_filter-1, WID(treeview0), stores[0], nb_active_filter-2);
break;
case A_VCD:
setVCD ();
updateFilterList ();
setSelectionNumber(nb_active_filter-1, WID(treeview0), stores[0], nb_active_filter-2);
break;
case A_SVCD:
setSVCD ();
updateFilterList ();
setSelectionNumber(nb_active_filter-1, WID(treeview0), stores[0], nb_active_filter-2);
break;
case A_DVD:
setDVD ();
updateFilterList ();
setSelectionNumber(nb_active_filter-1, WID(treeview0), stores[0], nb_active_filter-2);
break;
case A_HALFD1:
setHalfD1 ();
updateFilterList ();
setSelectionNumber(nb_active_filter-1, WID(treeview0), stores[0], nb_active_filter-2);
break;
default:
case A_DOUBLECLICK:
printf ("Double clicked..");
case A_CONFIGURE:
if(!action_parameter) break;
if(!videofilters[action_parameter].filter->
configure (videofilters[action_parameter - 1].filter)) break;
CONFcouple *couple;
videofilters[action_parameter].filter->getCoupledConf (&couple);
videofilters[action_parameter].conf = couple;
getFirstVideoFilter ();
updateFilterList ();
setSelectionNumber(nb_active_filter-1, WID(treeview0), stores[0], action_parameter-1);
break;
case A_PARTIAL:
if (!action_parameter) break;
AVDMGenericVideoStream *replace;
CONFcouple *conf;
conf = videofilters[action_parameter].conf;
if (videofilters[action_parameter].tag == VF_PARTIAL_FILTER) // cannot recurse
{
GUI_Error_HIG (QT_TR_NOOP("The filter is already partial"), NULL);
break;
}
replace =
new ADMVideoPartial (videofilters[action_parameter - 1].
filter,
videofilters[action_parameter].tag,
conf);
if(replace->configure (videofilters[action_parameter - 1].filter))
{
delete videofilters[action_parameter].filter;
if (conf) delete conf;
videofilters[action_parameter].filter = replace;
replace->getCoupledConf (&conf);
videofilters[action_parameter].conf = conf;
videofilters[action_parameter].tag = VF_PARTIAL_FILTER;
getFirstVideoFilter ();
updateFilterList ();
setSelectionNumber(nb_active_filter-1, WID(treeview0), stores[0], action_parameter-1);
}
else delete replace;
break;
case A_UP:
if (action_parameter < 2) break;
// swap action parameter & action parameter -1
FILTER tmp;
memcpy (&tmp, &videofilters[action_parameter - 1], sizeof (FILTER));
memcpy (&videofilters[action_parameter - 1],
&videofilters[action_parameter], sizeof (FILTER));
memcpy (&videofilters[action_parameter], &tmp, sizeof (FILTER));
getFirstVideoFilter ();
// select action_parameter -1
updateFilterList ();
setSelectionNumber (nb_active_filter - 1,
WID(treeview0),
stores[0], action_parameter - 2);
break;
case A_DOWN:
if (((int) action_parameter < (int) (nb_active_filter - 1)) && (action_parameter))
{
// swap action parameter & action parameter -1
FILTER tmp;
memcpy (&tmp, &videofilters[action_parameter + 1], sizeof (FILTER));
memcpy (&videofilters[action_parameter + 1],
&videofilters[action_parameter], sizeof (FILTER));
memcpy (&videofilters[action_parameter], &tmp, sizeof (FILTER));
getFirstVideoFilter ();
updateFilterList ();
setSelectionNumber (nb_active_filter - 1,
WID(treeview0),
stores[0], action_parameter);
}
break;
case A_REMOVE:
VF_FILTERS tag;
AVDMGenericVideoStream *old;
// we store the one we will delete
if (action_parameter < 1) break;
if (videofilters[action_parameter].conf)
{
delete videofilters[action_parameter].conf;
videofilters[action_parameter].conf = NULL;
}
// recreate derivated filters
for (uint32_t i = action_parameter + 1; i < nb_active_filter; i++)
{
delete videofilters[i - 1].filter;
videofilters[i - 1].filter = filterCreateFromTag(videofilters[i].tag,
videofilters[i].conf,
videofilters[i - 2].filter);
videofilters[i - 1].conf = videofilters[i].conf;
videofilters[i - 1].tag = videofilters[i].tag;
}
delete videofilters[nb_active_filter - 1].filter;
videofilters[nb_active_filter - 1].filter = NULL;
nb_active_filter--;
updateFilterList ();
if(!setSelectionNumber(nb_active_filter-1, WID(treeview0), stores[0], action_parameter-1))
setSelectionNumber(nb_active_filter-1, WID(treeview0), stores[0], action_parameter-2);
break;
case A_DONE:
break;
case A_PREVIEW:
if (!action_parameter) break;
extern uint32_t curframe;
DIA_filterPreview(QT_TR_NOOP("Preview"), videofilters[action_parameter].filter, curframe);
break;
case A_LOAD:
#ifdef USE_LIBXML2
GUI_FileSelRead (QT_TR_NOOP("Load set of filters"), filterLoadXml);
#else
GUI_FileSelRead (QT_TR_NOOP("Load set of filters"), filterLoad);
#endif
updateFilterList ();
setSelectionNumber(nb_active_filter-1, WID(treeview0), stores[0], 0);
break;
case A_CLOSE:
//gtk_widget_destroy(dialog);
gtk_signal_emit_by_name(GTK_OBJECT(dialog),"delete-event");
break;
case A_SAVE:
if (nb_active_filter < 2)
{
GUI_Error_HIG (QT_TR_NOOP("Nothing to save"), NULL);
}
else
#ifdef USE_LIBXML2
GUI_FileSelWrite (QT_TR_NOOP("Save set of filters"), filterSaveXml);
#else
GUI_FileSelWrite (QT_TR_NOOP("Save set of filters"), filterSave);
#endif
break;
#if 0
default:
printf ("Unknown action :%d, action param %d\n", action, action_parameter);
ADM_assert (0);
#endif
} //end of switch
}
/*--------------------------------------------------------------------*/
uint8_t mpegWritter::dopass2(char *name,char *statname,uint32_t final_size,uint32_t bitrate,
ADM_MPEGTYPE mpegtype,int matrix,uint8_t interlaced,
uint8_t bff, // WLA
uint8_t widescreen)
{
int intra,q;
uint32_t size;
AVDMGenericVideoStream *incoming;
FILE *fd=NULL;
uint64_t total_size=0;
uint32_t len,flags,type,outquant;
incoming = getLastVideoFilter (frameStart,frameEnd-frameStart);
if(!_audio)
{
fd=fopen(name,"wb");
if(!fd)
{
GUI_Alert("Problem opening file!");
return 0;
}
}
// if(!init(name,mpegtype,interlaced,widescreen))
if(!init(name,mpegtype,interlaced,bff,widescreen)) // WLA
{
printf("Mpeg2 init failed\n");
return 0;
}
printf("\n mpeg2enc init done \n");
assert( _buffer);
assert( _buffer_out);
encoding->reset();
encoding->setFrame (0, _total);
/*-------------------- Pass 1 over, go to pass 2 --------------------------------*/
total_size=0;
memset(&mpegvbr,0,sizeof(mpegvbr));
if(0> vbrSetDefaults(&mpegvbr))
{
printf("set default failed\n");
return 0;
}
mpegvbr.fps=_fps1000/1000.;
mpegvbr.mode=VBR_MODE_2PASS_2;
mpegvbr.desired_size=final_size*1024*1024;
mpegvbr.debug=0;
mpegvbr.filename=statname; //XvidInternal2pass_statfile;
float br;
uint32_t avg;
br=mpegvbr.desired_size*8;
br=br/_total; // bit / frame
br=br*mpegvbr.fps;
mpegvbr.desired_bitrate= (int)floor(br);
avg=(uint32_t)floor(br/1000.);
printf("average bitrate : %lu\n",avg);
//mpegvbr.maxAllowedBitrate=(2500*1000)>>3;
// enable stuff in xvid
//mpegvbr.twopass_max_bitrate=2500*1000;
//mpegvbr.alt_curve_high_dist=10;
//mpegvbr.alt_curve_low_dist=30;
//mpegvbr.alt_curve_type=VBR_ALT_CURVE_AGGRESIVE;
if(0>vbrInit(&mpegvbr))
{
GUI_Alert("Error initializing 2 pass!");
return 0;
}
encoding->setPhasis("2nd Pass");
q=2;
//mpegvbr.maxAllowedBitrate=(bitrate*1000)>>3;//(bitrate*1000)>>3;
//mpegvbr.maxAllowedBitrate=(9000*1000)>>3; // enable stuff in xvid
//->
switch(mpegtype)
{
case ADM_SVCD:
Mpeg2encSVCD *dec;
dec=new Mpeg2encSVCD(_w,_h);
dec->setMatrix(matrix);
// dec->init(q,bitrate,_fps1000,interlaced,widescreen);
dec->init(q,bitrate,_fps1000,interlaced,bff,widescreen); // WLA
_codec=dec;
encoding->setCodec("SVCD");
printf("Svcd max bitrate : %d\n",bitrate);
break;
case ADM_DVD:
{
Mpeg2encDVD *dec;
dec=new Mpeg2encDVD(_w,_h);
dec->setMatrix(matrix);
// dec->init(q,bitrate,_fps1000,interlaced,widescreen);
dec->init(q,bitrate,_fps1000,interlaced,bff,widescreen); // WLA
_codec=dec;
printf("DVD max bitrate : %d\n",bitrate);
encoding->setCodec("DVD");
}
break;
default:
assert(0);
break;
}
encoding->setPhasis("2nd Pass");
for(uint32_t i=0;i<_total;i++)
{
if(!incoming->getFrameNumberNoAlloc(i, &size,(uint8_t *) _buffer,&flags))
{
GUI_Alert("Encoding error !");
if(!_audio)
fclose(fd);
end();
return 0 ;
}
encoding->setFrame(i,_total);
if(i<MPEG_PREFILL)
{
_codec->encode(_buffer,_buffer_out , &len,&flags,&outquant);
continue;
}
encoding->feedFrame(len); // Set
/* prepare quantization for next gop */
//if(vbr_next_intra( &mpegvbr))
{
q=vbrGetQuant(&mpegvbr);
_codec->setQuantize(q);
}
_codec->encode(_buffer,_buffer_out , &len,&flags,&outquant);
encoding->setQuant(outquant);
if(flags & AVI_KEY_FRAME) intra=1;
else intra=0;
switch(flags)
{
case AVI_KEY_FRAME: type=1;
break;
case AVI_B_FRAME: type=3;
break;
default:
type=2;
break;
}
aprintf("inquant : %02d outquant %02d Intra %d size :%d flags %x\n",
q,outquant,intra,len,flags);
vbrUpdate(&mpegvbr,
outquant,
//q,
intra,
0,
len,
0,
0,
type);
total_size+=len;
if(!_audio)
{
fwrite(_buffer_out,len,1,fd);
fflush(fd);
}
else
{
fwrite(_buffer_out,len,1,_videoFifo);
fflush(_videoFifo);
len=_audioOneFrame;
len = _audio->read (len, _audioBuffer);
fwrite(_audioBuffer,len,1,_audioFifo);
fflush(_audioFifo);
}
if(!encoding->isAlive())
{
end();
fclose(fd);
return 0;
}
}
//--
// flush queue
for(uint32_t i=0;i<MPEG_PREFILL;i++)
{
q=vbrGetQuant(&mpegvbr);
_codec->setQuantize(q);
_codec->encode( _buffer,_buffer_out , &len,&flags,&outquant);
encoding->setQuant(outquant);
if(flags & AVI_KEY_FRAME) intra=1;
else intra=0;
switch(flags)
{
case AVI_KEY_FRAME: type=1;
break;
case AVI_B_FRAME: type=3;
break;
default:
type=2;
break;
}
printf("inquant : %02d outquant %02d Intra %d size :%d flags %x\n",q,outquant,
intra,len,flags);
vbrUpdate(&mpegvbr,
outquant,
//q,
intra,
0,
len,
0,
0,
type);
total_size+=len;
if(!_audio)
{
fwrite(_buffer_out,len,1,fd);
fflush(fd);
}
else
{
fwrite(_buffer_out,len,1,_videoFifo);
fflush(_videoFifo);
len=_audioOneFrame;
len = _audio->read (len, _audioBuffer);
fwrite(_audioBuffer,len,1,_audioFifo);
fflush(_audioFifo);
}
// printf("\n pipe opened %ld\n",i);
encoding->feedFrame(len); // Set
encoding->setFrame(i,MPEG_PREFILL);
}
//--
if(!_audio)
fclose(fd);
else
{
fflush(_audioFifo);
fflush(_videoFifo);
if(_audioFifo)
{
fclose(_audioFifo);
_audioFifo=NULL;
}
if(_videoFifo)
{
fclose(_videoFifo);
_videoFifo=NULL;
}
if(_lvepipe)
{
printf("Killing lvemux (main loop)\n");
pclose(_lvepipe);
_lvepipe=NULL;
}
}
end();
return 1;
}
/*-------------------------------------------------------------------------------------------------------*/
uint8_t mpegWritter::dopass1(char *name,char *statname,uint32_t final_size,uint32_t bitrate,
ADM_MPEGTYPE mpegtype,int matrix,uint8_t interlaced,
uint8_t bff, // WLA
uint8_t widescreen)
{
uint32_t size;
AVDMGenericVideoStream *incoming;
FILE *fd;
uint64_t total_size=0;
uint32_t len,flags,type,outquant;
float br;
uint32_t avg;
int intra,q;
incoming = getLastVideoFilter (frameStart,frameEnd-frameStart);
// if(!init(name,mpegtype,interlaced,widescreen)) return 0;
if(!init(name,mpegtype,interlaced,bff,widescreen)) return 0; // WLA
printf("\n mpeg2enc init done \n");
assert( _buffer);
assert( _buffer_out);
q=6; // q=2
encoding->setPhasis("1st Pass");
bitrate=0; // we dont care in pass 1 ...
memset(&mpegvbr,0,sizeof(mpegvbr));
if(0> vbrSetDefaults(&mpegvbr)) return 0;
mpegvbr.fps=_fps1000/1000.;
mpegvbr.mode=VBR_MODE_2PASS_1;
mpegvbr.desired_size=final_size*1024*1024;
mpegvbr.debug=0;
mpegvbr.filename=statname; //XvidInternal2pass_statfile;
br=mpegvbr.desired_size*8;
br=br/_total; // bit / frame
br=br*mpegvbr.fps;
br/=1000;
avg=(uint32_t)floor(br);
printf("Average bitrate : %lu\n",avg);
if(0> vbrInit(&mpegvbr)) return 0;
switch(mpegtype)
{
case ADM_SVCD:
Mpeg2encSVCD *dec;
dec=new Mpeg2encSVCD(_w,_h);
dec->setMatrix(matrix);
#ifdef ADM_1PASS_CBR
dec->disablePadding();
//dec->init(qz,bitrate,_fps1000,interlaced,widescreen);
// dec->init(0,avg*1000,_fps1000,interlaced,widescreen);
dec->init(0,avg*1000,_fps1000,interlaced,bff,widescreen); // WLA
#else
// dec->init(q,0,_fps1000,interlaced,widescreen);
dec->init(q,0,_fps1000,interlaced,bff,widescreen); // WLA
#endif
// 6 Megabits should be enough
//dec->init(0,avg,_fps1000); // 6 Megabits should be enough
_codec=dec;
encoding->setCodec("SVCD");
break;
case ADM_DVD:
{
Mpeg2encDVD *dec;
dec=new Mpeg2encDVD(_w,_h);
dec->setMatrix(matrix);
#ifdef ADM_1PASS_CBR
dec->disablePadding();
// dec->init(0,avg*1000,_fps1000,interlaced,widescreen);
dec->init(0,avg*1000,_fps1000,interlaced,bff,widescreen); // WLA
#else
// dec->init(q,0,_fps1000,interlaced,widescreen);
dec->init(q,0,_fps1000,interlaced,bff,widescreen); // WLA
#endif
_codec=dec;
encoding->setCodec("DVD");;
}
break;
default:
assert(0);
break;
}
encoding->setFrame (0, _total);
for(uint32_t i=0;i<_total;i++)
{
_codec->setQuantize(q);
if(! incoming->getFrameNumberNoAlloc(i, &size,(uint8_t *) _buffer,&flags))
{
GUI_Alert("Encoding error !");
end();
return 0 ;
}
if(i<MPEG_PREFILL)
{
_codec->encode(_buffer,_buffer_out , &len,&flags,&outquant);
continue;
}
_codec->encode( _buffer,_buffer_out , &len,&flags,&outquant);
total_size+=len;
if(flags & AVI_KEY_FRAME) intra=1;
else intra=0;
aprintf("inquant : %02d outquant :%02d Intra %d, len %lu\n",q,outquant,intra,len);
switch(flags)
{
case AVI_KEY_FRAME: type=1;
break;
case AVI_B_FRAME: type=3;
break;
default:
type=2;
break;
}
vbrUpdate(&mpegvbr,
outquant,
intra,
0,
len,
0,
0,
type);
encoding->setFrame(i,_total);
encoding->setQuant(outquant);
encoding->feedFrame(len);
if(!encoding->isAlive())
{
end();
return 0;
}
}
// flush queue
for(uint32_t i=0;i<MPEG_PREFILL;i++)
{
_codec->encode( _buffer,_buffer_out , &len,&flags,&outquant);
total_size+=len;
if(flags & AVI_KEY_FRAME) intra=1;
else intra=0;
aprintf("inquant : %02d outquant :%02d Intra %d\n",q,outquant,intra);
switch(flags)
{
case AVI_KEY_FRAME: type=1;
break;
case AVI_B_FRAME: type=3;
break;
default:
type=2;
break;
}
vbrUpdate(&mpegvbr,
outquant,
intra,
0,
len,
0,
0,
type);
encoding->setFrame(i,MPEG_PREFILL);
encoding->setQuant(outquant);
encoding->feedFrame(len);
}
// flush queue
delete _codec;
_codec=NULL;
vbrFinish(&mpegvbr);
return 1;
}
/*-------------------------------------------------------------------------------------------------------------------*/
uint8_t mpegWritter::save_dualpass(char *name,uint32_t final_size,uint32_t bitrate,ADM_MPEGTYPE mpegtype,
int matrix,uint8_t interlaced,
uint8_t bff, // WLA
uint8_t widescreen)
{
AVDMGenericVideoStream *incoming;
char *statname;
incoming = getLastVideoFilter (frameStart,frameEnd-frameStart);
_w=incoming->getInfo()->width;
_h=incoming->getInfo()->height;
_page=_w*_h;
_page+=_page>>1;
_fps1000=incoming->getInfo()->fps1000;
_total=incoming->getInfo()->nb_frames;
if(!_total) return 0;
_buffer =new uint8_t[_w*_h*2];
_buffer_out=new uint8_t[_w*_h*2];
statname=new char[strlen(name)+4+1];
strcpy(statname,name);
strcat(statname,".st");
printf("Matrix : %d\n\n",matrix);
encoding=new DIA_encoding(_fps1000);
encoding->setPhasis("Encoding");
// check if stat file exists ?
FILE *fd;
uint8_t reuse=0;
fd=fopen(statname,"rt");
if(fd)
{
fclose(fd);
if(GUI_Question("Reuse log file ?")) reuse=1;
}
#if 1
if(!reuse)
// if(!dopass1(name,statname,final_size,bitrate,mpegtype,matrix,interlaced,widescreen))
if(!dopass1(name,statname,final_size,bitrate,mpegtype,matrix,interlaced,bff,widescreen))
// WLA
{
delete encoding;
GUI_Alert("Error in pass 1");
delete [] statname;
return 0;
}
#endif
// if(!dopass2(name,statname,final_size,bitrate,mpegtype,matrix,interlaced,widescreen))
if(!dopass2(name,statname,final_size,bitrate,mpegtype,matrix,interlaced,bff,widescreen))
// WLA
{
delete encoding;
GUI_Alert("Error in pass 2");
delete [] statname;
return 0;
}
delete encoding;
delete [] statname;
return 1;
}
unsigned int calculatorDialog::getPictureSize(void)
{
AVDMGenericVideoStream *last = getLastVideoFilter();
return last->getInfo()->width * last->getInfo()->height;
}
//****************************************************************
uint8_t
mpegWritter::dopass2 (const char *name, char *statname, uint32_t final_size, uint32_t bitrate, ADM_MPEGTYPE mpegtype, int matrix, uint8_t interlaced, uint8_t bff, // WLA
uint8_t widescreen)
{
int intra, q;
uint32_t size;
AVDMGenericVideoStream *incoming;
FILE *fd = NULL;
uint64_t total_size = 0;
uint32_t len, flags, type, outquant, audiolen;
uint32_t sample_target = 0;
double sample_time;
ADMBitstream bitstream;
memset (quantstat, 0, 32);
incoming = getLastVideoFilter (frameStart, frameEnd - frameStart);
if (!_audio)
{
if (!(fd = qfopen (name, "wb")))
return 0;
}
// if(!init(name,mpegtype,interlaced,widescreen))
if (!init (name, mpegtype, interlaced, bff, widescreen)) // WLA
{
printf ("Mpeg2 init failed\n");
return 0;
}
printf ("\n mpeg2enc init done \n");
ADM_assert (aImage);
ADM_assert (_buffer_out);
encoding->reset ();
encoding->setFrame (0, _total);
/*-------------------- Pass 1 over, go to pass 2 --------------------------------*/
ADM_assert (_ratecontrol->startPass2 (final_size, _total));
encoding->setPhasis ("2nd Pass");
q = 2;
//mpegvbr.maxAllowedBitrate=(bitrate*1000)>>3;//(bitrate*1000)>>3;
//mpegvbr.maxAllowedBitrate=(9000*1000)>>3; // enable stuff in xvid
//->
switch (mpegtype)
{
case ADM_SVCD:
Mpeg2encSVCD * dec;
dec = new Mpeg2encSVCD (_w, _h);
dec->setMatrix (matrix);
// dec->init(q,bitrate,_fps1000,interlaced,widescreen);
dec->init (q, bitrate, _fps1000, interlaced, bff, widescreen, 0); // WLA
_codec = dec;
encoding->setCodec ("SVCD");
printf ("Svcd max bitrate : %d\n", bitrate);
break;
case ADM_DVD:
{
Mpeg2encDVD *dec;
dec = new Mpeg2encDVD (_w, _h);
dec->setMatrix (matrix);
// dec->init(q,bitrate,_fps1000,interlaced,widescreen);
dec->init (q, bitrate, _fps1000, interlaced, bff, widescreen, 0); // WLA
_codec = dec;
printf ("DVD max bitrate : %d\n", bitrate);
encoding->setCodec ("DVD");
}
break;
default:
ADM_assert (0);
break;
}
encoding->setPhasis ("2nd Pass");
if (_muxer)
{
encoding->
setAudioCodec (getStrFromAudioCodec (_audio->getInfo ()->encoding));
sample_time = _total;
sample_time *= 1000;
sample_time /= _fps1000; // target_time in second
sample_time *= _audio->getInfo ()->frequency;
sample_target = (uint32_t) floor (sample_time);
}
bitstream.data = _buffer_out;
for (uint32_t i = 0; i < _total; i++)
{
if (!incoming->getFrameNumberNoAlloc (i, &size, aImage, &flags))
{
GUI_Error_HIG (_("Encoding error"), NULL);
if (!_audio)
qfclose (fd);
end ();
return 0;
}
encoding->setFrame (i, _total);
if (i < MPEG_PREFILL)
{
_codec->encode (aImage, &bitstream); //_buffer_out , &len,&flags,&outquant);
quantstat[bitstream.out_quantizer]++;
continue;
}
// Set
//
ADM_rframe ftype, ztype;
uint32_t qz;
ADM_assert (_ratecontrol->getQz (&qz, &ztype));
q = qz;
//_codec->setQuantize(q);
bitstream.in_quantizer = q;
_codec->encode (aImage, &bitstream); //_buffer_out , &len,&flags,&outquant);
quantstat[bitstream.out_quantizer]++;
encoding->setQuant (bitstream.out_quantizer);
switch (bitstream.flags)
{
case AVI_KEY_FRAME:
ftype = RF_I;
break;
case AVI_B_FRAME:
ftype = RF_B;
break;
default:
ftype = RF_P;
break;
}
if (ftype != ztype)
{
printf ("**Frame type does not match %d %d\n", ztype, ftype);
}
//aprintf("inquant : %02d outquant %02d Intra %d size :%d flags %x\n",
// q,outquant,intra,len,flags);
ADM_assert (_ratecontrol->
logPass2 (bitstream.out_quantizer, ftype, bitstream.len));
total_size += bitstream.len;
encoding->feedFrame (bitstream.len);
if (!_muxer)
{
qfwrite (_buffer_out, bitstream.len, 1, fd);
fflush (fd);
}
else
{
// write video
_muxer->writeVideoPacket (&bitstream);
PACK_AUDIO;
}
if (!encoding->isAlive ())
{
print_quant_stat (name);
end ();
qfclose (fd);
return 0;
}
}
//--
// flush queue
for (uint32_t i = 0; i < MPEG_PREFILL; i++)
{
ADM_rframe ftype;
uint32_t qz;
ADM_assert (_ratecontrol->getQz (&qz, &ftype));
q = qz;
//_codec->setQuantize(q);
bitstream.in_quantizer = q;
_codec->encode (aImage, &bitstream); //_buffer_out , &len,&flags,&outquant);
quantstat[bitstream.out_quantizer]++;
encoding->setQuant (bitstream.out_quantizer);
switch (bitstream.flags)
{
case AVI_KEY_FRAME:
ftype = RF_I;
break;
case AVI_B_FRAME:
ftype = RF_B;
break;
default:
ftype = RF_P;
break;
}
//aprintf("inquant : %02d outquant %02d Intra %d size :%d flags %x\n",
// q,outquant,intra,len,flags);
ADM_assert (_ratecontrol->
logPass2 (bitstream.out_quantizer, ftype, bitstream.len));
total_size += bitstream.len;
if (!_muxer)
{
qfwrite (_buffer_out, bitstream.len, 1, fd);
fflush (fd);
}
else
{
// write video
_muxer->writeVideoPacket (&bitstream);
PACK_AUDIO;
}
// printf("\n pipe opened %ld\n",i);
encoding->feedFrame (bitstream.len); // Set
encoding->setQuant (bitstream.out_quantizer);
encoding->setFrame (i, MPEG_PREFILL);
}
//--
if (!_muxer)
qfclose (fd);
else
{
_muxer->close ();
delete _muxer;
_muxer = NULL;
}
print_quant_stat (name);
end ();
return 1;
}
/*-------------------------------------------------------------------------------------------------------*/
uint8_t
mpegWritter::dopass1 (const char *name, char *statname, uint32_t final_size, uint32_t bitrate, ADM_MPEGTYPE mpegtype, int matrix, uint8_t interlaced, uint8_t bff, // WLA
uint8_t widescreen)
{
uint32_t size;
AVDMGenericVideoStream *incoming;
FILE *fd;
uint64_t total_size = 0;
//uint32_t len,flags,type,outquant;
float br;
uint32_t avg, flags;
int intra, q;
ADMBitstream bitstream;
incoming = getLastVideoFilter (frameStart, frameEnd - frameStart);
// if(!init(name,mpegtype,interlaced,widescreen)) return 0;
if (!init (name, mpegtype, interlaced, bff, widescreen))
return 0; // WLA
printf ("\n mpeg2enc init done \n");
ADM_assert (aImage);
ADM_assert (_buffer_out);
q = 2; // q=2
encoding->setPhasis ("1st Pass");
bitrate = 0; // we dont care in pass 1 ...
ADM_assert (_ratecontrol->startPass1 ());
switch (mpegtype)
{
case ADM_SVCD:
Mpeg2encSVCD * dec;
dec = new Mpeg2encSVCD (_w, _h);
dec->setMatrix (matrix);
#ifdef ADM_1PASS_CBR
dec->disablePadding ();
//dec->init(qz,bitrate,_fps1000,interlaced,widescreen);
// dec->init(0,avg*1000,_fps1000,interlaced,widescreen);
dec->init (0, avg * 1000, _fps1000, interlaced, bff, widescreen, 1); // WLA
#else
// dec->init(q,0,_fps1000,interlaced,widescreen);
dec->init (q, 0, _fps1000, interlaced, bff, widescreen, 1); // WLA
#endif
// 6 Megabits should be enough
//dec->init(0,avg,_fps1000); // 6 Megabits should be enough
_codec = dec;
encoding->setCodec ("SVCD");
break;
case ADM_DVD:
{
Mpeg2encDVD *dec;
dec = new Mpeg2encDVD (_w, _h);
dec->setMatrix (matrix);
#ifdef ADM_1PASS_CBR
dec->disablePadding ();
// dec->init(0,avg*1000,_fps1000,interlaced,widescreen);
dec->init (0, avg * 1000, _fps1000, interlaced, bff, widescreen, 1); // WLA
#else
// dec->init(q,0,_fps1000,interlaced,widescreen);
dec->init (q, 0, _fps1000, interlaced, bff, widescreen, 1); // WLA
#endif
_codec = dec;
encoding->setCodec ("DVD");;
}
break;
default:
ADM_assert (0);
break;
}
encoding->setFrame (0, _total);
bitstream.data = _buffer_out;
for (uint32_t i = 0; i < _total; i++)
{
if (!incoming->getFrameNumberNoAlloc (i, &size, aImage, &flags))
{
GUI_Error_HIG (_("Encoding error"), NULL);
end ();
return 0;
}
if (i < MPEG_PREFILL)
{
bitstream.cleanup (i);
bitstream.in_quantizer=q;
_codec->encode (aImage, &bitstream);
//_buffer_out , &len,&flags,&outquant);
continue;
}
bitstream.cleanup (i);
_codec->encode (aImage, &bitstream); //_buffer_out , &len,&flags,&outquant);
total_size += bitstream.len;
// aprintf("inquant : %02d outquant :%02d Intra %d, len %lu\n",q,outquant,intra,len);
ADM_rframe ftype;
switch (bitstream.flags)
{
case AVI_KEY_FRAME:
ftype = RF_I;
break;
case AVI_B_FRAME:
ftype = RF_B;
break;
default:
ftype = RF_P;
break;
}
ADM_assert (_ratecontrol->
logPass1 (bitstream.out_quantizer, ftype, bitstream.len));
encoding->setFrame (i, _total);
encoding->setQuant (bitstream.out_quantizer);
encoding->feedFrame (bitstream.len);
if (!encoding->isAlive ())
{
end ();
return 0;
}
}
// flush queue
for (uint32_t i = 0; i < MPEG_PREFILL; i++)
{
bitstream.cleanup (i);
_codec->encode (aImage, &bitstream); //_buffer_out , &len,&flags,&outquant);
total_size += bitstream.len;
aprintf ("inquant : %02d outquant :%02d Intra %d\n", q,
bitstream.out_quantizer, intra);
ADM_rframe ftype;
switch (bitstream.flags)
{
case AVI_KEY_FRAME:
ftype = RF_I;
break;
case AVI_B_FRAME:
ftype = RF_B;
break;
default:
ftype = RF_P;
break;
}
ADM_assert (_ratecontrol->
logPass1 (bitstream.out_quantizer, ftype, bitstream.len));
encoding->setFrame (i, MPEG_PREFILL);
encoding->setQuant (bitstream.out_quantizer);
encoding->feedFrame (bitstream.len);
}
// flush queue
delete _codec;
_codec = NULL;
return 1;
}
/*-------------------------------------------------------------------------------------------------------------------*/
uint8_t
mpegWritter::save_dualpass (const char *name, uint32_t final_size, uint32_t bitrate, ADM_MPEGTYPE mpegtype, int matrix, uint8_t interlaced, uint8_t bff, // WLA
uint8_t widescreen)
{
AVDMGenericVideoStream *incoming;
char *statname;
uint32_t reuse = 0;
incoming = getLastVideoFilter (frameStart, frameEnd - frameStart);
_w = incoming->getInfo ()->width;
_h = incoming->getInfo ()->height;
_page = _w * _h;
_page += _page >> 1;
_fps1000 = incoming->getInfo ()->fps1000;
_total = incoming->getInfo ()->nb_frames;
if (!_total)
return 0;
//_buffer =new uint8_t[_w*_h*2];
aImage = new ADMImage (_w, _h);
_buffer_out = new uint8_t[_w * _h * 2];
statname = new char[strlen (name) + 4 + 1];
strcpy (statname, name);
strcat (statname, ".st");
printf ("Matrix : %d\n\n", matrix);
encoding = new DIA_encoding (_fps1000);
encoding->setPhasis ("Encoding");
// check if stat file exists ?
#if 1 //ndef CYG_MANGLING
{
FILE *fd;
fd = fopen (statname, "rt");
if (fd)
{
fclose (fd);
prefs->get (FEATURE_REUSE_2PASS_LOG, (uint32_t *) & reuse);
if (!reuse && GUI_Question (_("Reuse log file ?")))
reuse = 1;
}
}
#endif
//_ratecontrol=new ADM_oldXvidRc(_fps1000,statname);
_ratecontrol = new ADM_newXvidRc (_fps1000, statname);
#if 1
if (!reuse)
// if(!dopass1(name,statname,final_size,bitrate,mpegtype,matrix,interlaced,widescreen))
if (!dopass1
(name, statname, final_size, bitrate, mpegtype, matrix, interlaced,
bff, widescreen))
// WLA
{
delete encoding;
GUI_Error_HIG (_("Error in pass 1"), NULL);
delete[]statname;
return 0;
}
#endif
// if(!dopass2(name,statname,final_size,bitrate,mpegtype,matrix,interlaced,widescreen))
if (!dopass2
(name, statname, final_size, bitrate, mpegtype, matrix, interlaced, bff,
widescreen))
// WLA
{
delete encoding;
GUI_Error_HIG (_("Error in pass 2"), NULL);
delete[]statname;
return 0;
}
delete encoding;
delete[]statname;
return 1;
}
/*
Save as with the external mpeg2enc
*/
uint8_t
mpegWritter::save_regular (const char *name, ADM_MPEGTYPE mpegtype, int qz, int bitrate, int matrix, uint8_t interlaced, uint8_t bff, // WLA
uint8_t widescreen)
{
uint32_t size;
AVDMGenericVideoStream *incoming;
FILE *fd = NULL;
uint64_t total_size = 0;
uint32_t len, flags;
uint32_t outquant;
uint32_t audiolen = 0;
DIA_encoding *encoding;
uint32_t sample_target = 0;
double sample_time;
ADMBitstream bitstream;
incoming = getLastVideoFilter (frameStart, frameEnd - frameStart);
_total = incoming->getInfo ()->nb_frames;
_fps1000 = incoming->getInfo ()->fps1000;
if (!_total)
{
GUI_Error_HIG (_("No frames to encode"),
_("Please check markers. Is \"A>\" == \">B\"?"));
return 0;
}
printf ("Br:%d, qz:%d\n", bitrate, qz);
if (!_audio)
{
if (!(fd = qfopen (name, "wb")))
return 0;
}
else
{
ADM_assert (_muxer);
sample_time = _total;
sample_time *= 1000;
sample_time /= _fps1000; // target_time in second
sample_time *= _audio->getInfo ()->frequency;
sample_target = (uint32_t) floor (sample_time);
}
_w = incoming->getInfo ()->width;
_h = incoming->getInfo ()->height;
_page = _w * _h;
_page += _page >> 1;
// if(!init(name,ADM_VCD,interlaced,widescreen)) return 0;
if (!init (name, ADM_VCD, interlaced, bff, widescreen))
return 0; //WLA
printf ("\n mpeg2enc init done \n");
//_buffer =new uint8_t[_w*_h*2];
aImage = new ADMImage (_w, _h);
_buffer_out = new uint8_t[_w * _h * 2];
ADM_assert (aImage);
ADM_assert (_buffer_out);
encoding = new DIA_encoding (_fps1000);
encoding->setPhasis ("Encoding.");
encoding->setFrame (0, _total);
// printf("Br:%d, qz:%d\n",bitrate,qz);
switch (mpegtype)
{
case ADM_VCD:
{
encoding->setCodec ("VCD.");
Mpeg2encVCD *dec;
dec = new Mpeg2encVCD (_w, _h);
// dec->init(1,0,_fps1000,interlaced,widescreen);
dec->init (1, 0, _fps1000, interlaced, bff, widescreen, 0); // WLA
_codec = dec;
}
break;
case ADM_SVCD:
Mpeg2encSVCD * dec;
dec = new Mpeg2encSVCD (_w, _h);
dec->setMatrix (matrix);
// dec->init(qz,bitrate,_fps1000,interlaced,widescreen);
dec->init (qz, bitrate, _fps1000, interlaced, bff, widescreen, 0);
// WLA
_codec = dec;
encoding->setCodec ("SVCD.");
break;
case ADM_DVD:
{
Mpeg2encDVD *dec;
dec = new Mpeg2encDVD (_w, _h);
dec->setMatrix (matrix);
// dec->init(qz,bitrate,_fps1000,interlaced,widescreen);
dec->init (qz, bitrate, _fps1000, interlaced, bff, widescreen, 0);
// WLA
_codec = dec;
encoding->setCodec ("DVD.");
}
break;
default:
ADM_assert (0);
}
printf ("\n--encoding started--\n");
if (_muxer)
{
if (audioProcessMode ())
encoding->
setAudioCodec (getStrFromAudioCodec (_audio->getInfo ()->encoding));
else
encoding->setAudioCodec ("Copy");
switch (_outputAs)
{
case MUXER_TS:
encoding->setContainer ("Mpeg TS");
break;
case MUXER_VCD:
encoding->setContainer ("Mpeg VCD");
break;
case MUXER_SVCD:
encoding->setContainer ("Mpeg SVCD");
break;
case MUXER_DVD:
encoding->setContainer ("Mpeg DVD");
break;
default:
ADM_assert (0);
}
}
else
encoding->setContainer ("Mpeg ES");
bitstream.data = _buffer_out;
for (uint32_t i = 0; i < _total; i++)
{
if (!incoming->getFrameNumberNoAlloc (i, &size, aImage, &flags))
{
delete encoding;
GUI_Error_HIG (_("Encoding error"), NULL);
if (fd)
qfclose (fd);
end ();
return 0;
}
bitstream.cleanup (i);
bitstream.in_quantizer=0;
_codec->encode (aImage, &bitstream);
//_buffer_out , &len,&flags,&outquant);
total_size += bitstream.len;
encoding->feedFrame (bitstream.len);
encoding->setQuant (bitstream.out_quantizer);
encoding->setFrame (i, _total);
// Null frame are only possible
// when in prefill state for mpeg-X
if (!len)
continue;
if (_muxer)
{
#warning FIXME
#warning FIXME
#warning FIXME
#warning FIXME
_muxer->writeVideoPacket (&bitstream);
PACK_AUDIO;
}
else
{
qfwrite (_buffer_out, bitstream.len, 1, fd);
fflush (fd);
}
aprintf (" outquant %02d size :%d flags %x\n", outquant, len, flags);
if (!encoding->isAlive ())
{
delete encoding;
end ();
if (fd)
qfclose (fd);
return 0;
}
}
encoding->setPhasis ("Finishing");
bitstream.data = _buffer_out;
for (uint32_t i = 0; i < MPEG_PREFILL; i++)
{
bitstream.cleanup (i);
_codec->encode (aImage, &bitstream); //_buffer_out , &len,&flags);
total_size += bitstream.len;
encoding->feedFrame (bitstream.len);
if (!_muxer)
qfwrite (_buffer_out, bitstream.len, 1, fd);
else
{
_muxer->writeVideoPacket (&bitstream);
PACK_AUDIO;
}
// printf("\n pipe opened %ld\n",i);
encoding->setFrame (i, _total);
}
delete encoding;
if (!_muxer)
qfclose (fd);
else
{
_muxer->close ();
delete _muxer;
_muxer = NULL;
deleteAudioFilter (_audio);
_audio = NULL;
}
end ();
return 1;
}
//static uint8_t Vbuffer[7.0*5.6*3];
//AVDMGenericVideoStream *getFirstVideoFilter( void)
//
//_____________________________________________________________
void GUI_PlayAvi(void)
{
uint32_t time_e, time_a = 0;
uint32_t err = 0, acc = 0;
uint32_t max;
uint32_t framelen,flags;
AVDMGenericVideoStream *filter;
ADMImage *buffer=NULL;
vids = 0, auds = 0, dauds = 0;
// check we got everything...
if (!avifileinfo)
return;
if((curframe+1)>= avifileinfo->nb_frames-1)
{
printf("No frame left\n");
return;
}
if (avifileinfo->fps1000 == 0)
return;
if (playing)
{
stop_req = 1;
return;
}
uint32_t played_frame=0;
uint32_t remaining=avifileinfo->nb_frames-curframe;
if(guiOutputDisplay)
{
filter=getLastVideoFilter(curframe,remaining);
if(mode_preview)
{
editorKillPreview ();
UI_setPreviewToggleStatus( 0 );
mode_preview=0;
}
}
else
{
filter=getFirstVideoFilter(curframe,remaining );
}
max=filter->getInfo()->nb_frames;
// compute how much a frame lasts in ms
one_frame = (uint32_t) floor(1000.*1000.*10. / filter->getInfo()->fps1000);
err = one_frame % 10;
one_frame /= 10; // Duration of a frame in ms, err =leftover in 1/10 ms
buffer=new ADMImage(filter->getInfo()->width,filter->getInfo()->height);
// go to RealTime...
printf(" One frame : %lu, err=%lu ms\n", one_frame, err);
// read frame in chunk
if(!filter->getFrameNumberNoAlloc(1,&framelen,buffer,&flags))
{
printf("\n cannot read frame!\n");
goto abort_play;
}
curframe++;
played_frame++;
// prepare 1st frame
stop_req = 0;
playing = 1;
#ifdef HAVE_AUDIO
ComputePreload();
#endif
renderResize(filter->getInfo()->width,filter->getInfo()->height,currentZoom);
renderStartPlaying();
// reset timer reference
resetTime();
do
{
vids++;
renderUpdateImage(buffer->data);
if(mode_preview&&!guiOutputDisplay)
{
editorUpdatePreview(played_frame);
}
update_status_bar(buffer);
if (time_a == 0)
time_a = getTime(0);
// mark !
//printf("\n Rendering %lu frame\n",curframe);
// read frame in chunk
if((played_frame)>=(max-1))
{
printf("\n End met (%lu / %lu )\n",played_frame,max);
goto abort_play;
}
if(!filter->getFrameNumberNoAlloc(played_frame+1,&framelen,buffer,&flags))
{
printf("\n cannot read frame!\n");
goto abort_play;
}
curframe++;
played_frame++;
#ifdef HAVE_AUDIO
FillAudio();
#endif
time_e = getTime(1);
acc += err;
if (acc > 10)
{
acc -= 10;
time_a++;
}
time_a += one_frame;
// delta a is next frame time
// time is is current time
delta = time_a - time_e;
if (delta <= 0)
{
//if(delta<-19) // allow 19 ms late without warning...
// tick seems to be ~ 18 ms
//printf("\n Late ....,due : %lu ms / found : %lu \n",
// time_a,time_e);
// a call to whatever sleep function will last at leat 10 ms
// give some time to GTK
} else
{
// a call to whatever sleep function will last at leat 10 ms
// give some time to GTK
if (delta > 10)
GUI_Sleep(delta - 10);
}
//
UI_purge();
if(mode_preview)
{
UI_purge();
UI_purge();
}
}
while (!stop_req);
abort_play:
// ___________________________________
// Flush buffer
// go back to normal display mode
//____________________________________
playing = 0;
delete buffer;
renderStopPlaying();
renderResize(avifileinfo->width , avifileinfo->height,currentZoom);
getFirstVideoFilter( );
//video_body->getUncompressedFrame(curframe, rdr_decomp_buffer,&flags);
GUI_getFrame(curframe, rdr_decomp_buffer, &flags);
renderUpdateImage(rdr_decomp_buffer->data);
renderRefresh();
update_status_bar(rdr_decomp_buffer);
if(mode_preview)
{
editorUpdatePreview(curframe);
}
#ifdef HAVE_AUDIO
if (currentaudiostream)
{
if (wavbuf)
ADM_dealloc(wavbuf);
deleteAudioFilter(NULL);
currentaudiostream->endDecompress();
AVDM_AudioClose();
}
#endif
// done.
};
//static uint8_t Vbuffer[7.0*5.6*3];
//AVDMGenericVideoStream *getFirstVideoFilter( void)
//
//_____________________________________________________________
void GUI_PlayAvi(bool forceStop)
{
uint32_t time_e, time_a = 0;
uint32_t err = 0, acc = 0;
uint32_t max;
uint32_t framelen,flags;
AVDMGenericVideoStream *filter;
vids = 0, auds = 0, dauds = 0;
// check we got everything...
if (!avifileinfo)
return;
if((curframe+1)>= avifileinfo->nb_frames-1)
{
printf("No frame left\n");
return;
}
if (avifileinfo->fps1000 == 0)
return;
if (playing || forceStop)
{
stop_req = 1;
return;
}
uint32_t priorityLevel;
originalPriority = getpriority(PRIO_PROCESS, 0);
prefs->get(PRIORITY_PLAYBACK,&priorityLevel);
setpriority(PRIO_PROCESS, 0, ADM_getNiceValue(priorityLevel));
uint32_t played_frame=0;
uint32_t remaining=avifileinfo->nb_frames-curframe;
if(getPreviewMode()==ADM_PREVIEW_OUTPUT)
{
filter=getLastVideoFilter(curframe,remaining);
}
else
{
filter=getFirstVideoFilter(curframe,remaining );
}
max=filter->getInfo()->nb_frames;
// compute how much a frame lasts in ms
one_frame = (uint32_t) floor(1000.*1000.*10. / filter->getInfo()->fps1000);
err = one_frame % 10;
one_frame /= 10; // Duration of a frame in ms, err =leftover in 1/10 ms
// go to RealTime...
printf("One frame : %lu, err=%lu ms\n", one_frame, err);
// prepare 1st frame
stop_req = 0;
playing = 1;
#ifdef HAVE_AUDIO
ComputePreload();
#endif
//renderStartPlaying();
// reset timer reference
resetTime();
admPreview::deferDisplay(1,curframe);
admPreview::update(played_frame);
do
{
vids++;
admPreview::displayNow(played_frame);;
update_status_bar();
if (time_a == 0)
time_a = getTime(0);
// mark !
//printf("\n Rendering %lu frame\n",curframe);
// read frame in chunk
if((played_frame)>=(max-1))
{
printf("\nEnd met (%lu / %lu )\n",played_frame,max);
goto abort_play;
}
admPreview::update(played_frame+1);;
curframe++;
played_frame++;
#ifdef HAVE_AUDIO
FillAudio();
#endif
time_e = getTime(1);
acc += err;
if (acc > 10)
{
acc -= 10;
time_a++;
}
time_a += one_frame;
// delta a is next frame time
// time is is current time
delta = time_a - time_e;
if (delta <= 0)
{
//if(delta<-19) // allow 19 ms late without warning...
// tick seems to be ~ 18 ms
//printf("\n Late ....,due : %lu ms / found : %lu \n",
// time_a,time_e);
// a call to whatever sleep function will last at leat 10 ms
// give some time to GTK
} else
{
// a call to whatever sleep function will last at leat 10 ms
// give some time to GTK
if (delta > 10)
GUI_Sleep(delta - 10);
}
//
UI_purge();
if(getPreviewMode()==ADM_PREVIEW_SEPARATE )
{
UI_purge();
UI_purge();
}
}
while (!stop_req);
abort_play:
// ___________________________________
// Flush buffer
// go back to normal display mode
//____________________________________
playing = 0;
getFirstVideoFilter( );
admPreview::deferDisplay(0,0);
UI_purge();
// Updated by expose ?
admPreview::update(curframe);
UI_purge();
update_status_bar();
#ifdef HAVE_AUDIO
if (currentaudiostream)
{
if (wavbuf)
ADM_dealloc(wavbuf);
deleteAudioFilter(NULL);
currentaudiostream->endDecompress();
AVDM_AudioClose();
}
#endif
// done.
setpriority(PRIO_PROCESS, 0, originalPriority);
};
uint8_t DIA_threshold (AVDMGenericVideoStream *in,
ADMVideoThreshold * thresholdp,
THRESHOLD_PARAM * param)
{
// Allocate space for preview video
uint32_t width = in->getInfo()->width;
uint32_t height = in->getInfo()->height;
dialog = create_threshold_dialog();
gtk_dialog_set_alternative_button_order(GTK_DIALOG(dialog),
GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL,
-1);
gtk_register_dialog(dialog);
gtk_window_set_title (GTK_WINDOW (dialog),
QT_TR_NOOP("Threshold Configuration"));
gtk_widget_show(dialog);
myDialog = new flyThreshold (width, height, in,
WID(previewVideo), WID(previewSlider),
thresholdp, param);
g_signal_connect (GTK_OBJECT (WID(previewVideo)), "configure-event",
GTK_SIGNAL_FUNC (preview_video_configured),
gpointer (myDialog));
myDialog->upload();
myDialog->sliderChanged();
// update things when settings are changed
#define CNX(_widg,_signame) \
g_signal_connect(GTK_OBJECT(WID(_widg)), _signame, \
GTK_SIGNAL_FUNC(gui_update), (void *) (1));
// CNX (minValueSlider, "drag_data_received");
CNX (minValueSpinner, "value_changed");
// CNX (maxValueSlider, "drag_data_received");
CNX (maxValueSpinner, "value_changed");
CNX (outputValuesMenu, "changed");
g_signal_connect(GTK_OBJECT(WID(previewSlider)), "value_changed",
GTK_SIGNAL_FUNC(frame_changed), 0);
g_signal_connect(GTK_OBJECT(WID(previewVideo)), "expose_event",
GTK_SIGNAL_FUNC(gui_draw), 0);
g_signal_connect(GTK_OBJECT(WID(previewVideo)), "button_press_event",
GTK_SIGNAL_FUNC(previewButtonEvent),
gpointer(myDialog));
#if 0
g_signal_connect(GTK_OBJECT(WID(previewVideo)), "motion_notify_event",
GTK_SIGNAL_FUNC(previewMotionEvent),
gpointer(myDialog));
#endif
GtkWidget * previewOutputMenu = WID(previewOutputMenu);
uint32_t filter_count;
FILTER * filters = getCurrentVideoFilterList (&filter_count);
int32_t active = -1;
// The " + (active < 0)" below is a bit of a hack. We know that in
// on_action() in gui_filtermanager.cpp, case A_ADD, the new filter-to-be
// is added to the filter list without incrementing nb_active_filter yet.
// So if we get to the end of the list and haven't yet found the filter
// that we're configuring, we know it's a new one and therefore that it is
// one past the apparent end of the list. It's not a clean solution, but
// it seems like the cleanEST solution.
for (uint32_t i = 0; i < filter_count + (active < 0); i++)
{
const char * name
= (i == 0) ? "(input)" : filterGetNameFromTag (filters [i].tag);
bool free_name = false;
FILTER * filter = filters + i;
AVDMGenericVideoStream * source = filter->filter;
uint32_t w = source->getInfo()->width;
uint32_t h = source->getInfo()->height;
if (w != width || h != height)
{
name = g_strconcat ("XX ", name, " XX", NULL);
free_name = true;
}
printf ("filter [%d] = %s (%d) @ %p; %dx%d\n",
i, name, filter->tag, source, w, h);
gtk_combo_box_append_text (GTK_COMBO_BOX (previewOutputMenu), name);
if (filter->filter == myDialog->getSource())
{
gtk_combo_box_set_active (GTK_COMBO_BOX (previewOutputMenu), i);
printf ("\tfilter [%d] is being configured now\n", i);
active = i;
}
if (free_name)
g_free (const_cast <char *> (name));
}
ADM_assert (active >= 0);
myDialog->this_filter_index = active;
g_signal_connect (GTK_OBJECT(previewOutputMenu), "changed",
GTK_SIGNAL_FUNC(previewOutputMenuChange),
gpointer(myDialog));
uint8_t ret = 0;
int response = gtk_dialog_run(GTK_DIALOG(dialog));
if (response == GTK_RESPONSE_OK)
{
myDialog->download();
myDialog->pushParam();
ret = 1;
}
else
myDialog->restoreParam();
gtk_unregister_dialog(dialog);
gtk_widget_destroy(dialog);
delete myDialog;
return ret;
}
/*
Save as with the external mpeg2enc
*/
uint8_t mpegWritter::save_regular(char *name, ADM_MPEGTYPE mpegtype, int qz, int bitrate,int matrix,
uint8_t interlaced,
uint8_t bff, // WLA
uint8_t widescreen)
{
uint32_t size;
AVDMGenericVideoStream *incoming;
FILE *fd=NULL;
uint64_t total_size=0;
uint32_t len,flags;
uint32_t outquant;
DIA_encoding *encoding;
incoming = getLastVideoFilter (frameStart,frameEnd-frameStart);
_total=incoming->getInfo()->nb_frames;
_fps1000=incoming->getInfo()->fps1000;
if(!_total) return 0;
printf("Br:%d, qz:%d\n",bitrate,qz);
if(!_audio)
{
fd=fopen(name,"wb");
if(!fd)
{
GUI_Alert("Problem opening file!");
return 0;
}
}
else
{
assert(_audioOneFrame);
assert(_audioBuffer);
assert(_audioFifo);
assert(_videoFifo);
}
_w=incoming->getInfo()->width;
_h=incoming->getInfo()->height;
_page=_w*_h;
_page+=_page>>1;
// if(!init(name,ADM_VCD,interlaced,widescreen)) return 0;
if(!init(name,ADM_VCD,interlaced,bff,widescreen)) return 0; //WLA
printf("\n mpeg2enc init done \n");
_buffer =new uint8_t[_w*_h*2];
_buffer_out=new uint8_t[_w*_h*2];
assert( _buffer);
assert( _buffer_out);
encoding=new DIA_encoding(_fps1000);
encoding->setPhasis("Encoding.");
encoding->setFrame(0,_total);
// printf("Br:%d, qz:%d\n",bitrate,qz);
switch(mpegtype)
{
case ADM_VCD:
{
encoding->setCodec("VCD.");
Mpeg2encVCD *dec;
dec=new Mpeg2encVCD(_w,_h);
// dec->init(1,0,_fps1000,interlaced,widescreen);
dec->init(1,0,_fps1000,interlaced,bff,widescreen); // WLA
_codec=dec;
}
break;
case ADM_SVCD:
Mpeg2encSVCD *dec;
dec=new Mpeg2encSVCD(_w,_h);
dec->setMatrix(matrix);
// dec->init(qz,bitrate,_fps1000,interlaced,widescreen);
dec->init(qz,bitrate,_fps1000,interlaced,bff,widescreen);
// WLA
_codec=dec;
encoding->setCodec("SVCD.");
break;
case ADM_DVD:
{
Mpeg2encDVD *dec;
dec=new Mpeg2encDVD(_w,_h);
dec->setMatrix(matrix);
// dec->init(qz,bitrate,_fps1000,interlaced,widescreen);
dec->init(qz,bitrate,_fps1000,interlaced,bff,widescreen);
// WLA
_codec=dec;
encoding->setCodec("DVD.");
}
break;
default: assert(0);
}
printf("\n--encoding started--\n");
for(uint32_t i=0;i<_total;i++)
{
if(!incoming->getFrameNumberNoAlloc(i, &size,
(uint8_t *) _buffer,&flags))
{
delete encoding;
GUI_Alert("Encoding error !");
if(fd)
fclose(fd);
end();
return 0 ;
}
_codec->encode( _buffer,_buffer_out , &len,&flags,&outquant);
total_size+=len;
encoding->feedFrame(len);
encoding->setQuant(outquant);
encoding->setFrame(i,_total);
// Null frame are only possible
// when in prefill state for mpeg-X
if(!len) continue;
if(_audio)
{
uint32_t audiolen;
// write video
fwrite(_buffer_out,len,1,_videoFifo);
fflush(_videoFifo);
audiolen=_audioOneFrame;
audiolen = _audio->read (audiolen,_audioBuffer);
assert(audiolen<MAXAUDIO);
fwrite(_audioBuffer,audiolen,1,_audioFifo);
fflush(_audioFifo);
aprintf("Audio :%lu Video:%lu (%lu)\n",audiolen,len,
_audioOneFrame);
}else
{
fwrite(_buffer_out,len,1,fd);
fflush(fd);
}
aprintf(" outquant %02d size :%d flags %x\n",outquant,len,flags);
if(!encoding->isAlive())
{
delete encoding;
end();
if(fd)
fclose(fd);
return 0;
}
}
encoding->setPhasis("Finishing");
for(uint32_t i=0;i<MPEG_PREFILL;i++)
{
_codec->encode(_buffer,_buffer_out , &len,&flags);
total_size+=len;
encoding->feedFrame(len);
if(!_audio)
fwrite(_buffer_out,len,1,fd);
else
{
fwrite(_buffer_out,len,1,_videoFifo);
len=_audioOneFrame;
len = _audio->read (len, _audioBuffer);
fwrite(_audioBuffer,len,1,_audioFifo);
}
// printf("\n pipe opened %ld\n",i);
encoding->setFrame(i,_total);
}
delete encoding;
if(!_audio)
fclose(fd);
else
{
fflush(_audioFifo);
fflush(_videoFifo);
if(_audioFifo)
{
fclose(_audioFifo);
_audioFifo=NULL;
}
if(_videoFifo)
{
fclose(_videoFifo);
_videoFifo=NULL;
}
if(_lvepipe)
{
printf("Killing lvemux (main loop)\n");
pclose(_lvepipe);
_lvepipe=NULL;
}
deleteAudioFilter();
_audio=NULL;
}
end();
return 1;
}
