int DIA_getLameSettings(ADM_audioEncoderDescriptor *descriptor)
  {
    int ret=0;
    char string[400];
    uint32_t mmode,ppreset;
#define SZT(x) sizeof(x)/sizeof(diaMenuEntry )
#define PX(x) &(lameParam->x)
    
    
    LAME_encoderParam *lameParam;
    ADM_assert(sizeof(LAME_encoderParam)==descriptor->paramSize);
  
    lameParam=(LAME_encoderParam*)descriptor->param;
    mmode=lameParam->mode;
    ppreset=lameParam->preset;
    diaMenuEntry channelMode[]={
                             {ADM_STEREO,      QT_TR_NOOP("Stereo"),NULL},
                             {ADM_JSTEREO,   QT_TR_NOOP("Joint stereo"),NULL},
                             {ADM_MONO,      QT_TR_NOOP("Mono"),NULL}};
          
    diaElemMenu menuMode(&mmode,   QT_TR_NOOP("C_hannel mode:"), SZT(channelMode),channelMode);
    
    diaMenuEntry encodingMode[]={
                             {ADM_LAME_PRESET_CBR,      QT_TR_NOOP("CBR"),NULL},
                             {ADM_LAME_PRESET_ABR,   QT_TR_NOOP("ABR"),NULL},
#if 0
                             {ADM_LAME_PRESET_EXTREME,      QT_TR_NOOP("Extreme"),NULL}
#endif
    }; 
    diaElemMenu Mode(&ppreset,   QT_TR_NOOP("Bit_rate mode:"), SZT(encodingMode),encodingMode);
#define BITRATE(x) {x,QT_TR_NOOP(#x)}
    diaMenuEntry bitrateM[]={
                              BITRATE(56),
                              BITRATE(64),
                              BITRATE(80),
                              BITRATE(96),
                              BITRATE(112),
                              BITRATE(128),
                              BITRATE(160),
                              BITRATE(192),
                              BITRATE(224)
                          };
    diaElemMenu bitrate(&(descriptor->bitrate),   QT_TR_NOOP("_Bitrate:"), SZT(bitrateM),bitrateM);
    
    
    
    
    diaElemUInteger quality(PX(quality),QT_TR_NOOP("_Quality:"),0,9);
    diaElemToggle reservoir(PX(disableReservoir),QT_TR_NOOP("_Disable reservoir:"));
  
      diaElem *elems[]={&menuMode,&Mode,&quality,&bitrate,&reservoir};
    
  if( diaFactoryRun(QT_TR_NOOP("LAME Configuration"),5,elems))
  {
    lameParam->mode=(ADM_mode)mmode; 
    lameParam->preset=(ADM_LAME_PRESET)ppreset;
    return 1;
  }
  return 0;
}  

bool         nvEncConfigure(void)
{
diaMenuEntry mePreset[]={ 
  {NV_PRESET_HP,QT_TRANSLATE_NOOP("nvenc",  "Low Quality")},
  {NV_PRESET_HQ,QT_TRANSLATE_NOOP("nvenc",  "High Quality")},
  {NV_PRESET_BD,QT_TRANSLATE_NOOP("nvenc",  "BluRay")},
  {NV_PRESET_LL,QT_TRANSLATE_NOOP("nvenc",  "Low Latency")},
  {NV_PRESET_LLHP,QT_TRANSLATE_NOOP("nvenc","Low Latency (LQ)")},
  {NV_PRESET_LLHQ,QT_TRANSLATE_NOOP("nvenc","Low Latency (HQ)")}
};

        nvencconf *conf=&NvEncSettings;

#define PX(x) &(conf->x)

        diaElemMenu      qzPreset(PX(preset),QT_TRANSLATE_NOOP("nvenc","Preset:"),6,mePreset);        
        diaElemUInteger  bitrate(PX(bitrate),QT_TRANSLATE_NOOP("nvenc","Bitrate (kbps):"),1,50000);
        diaElemUInteger  maxBitrate(PX(max_bitrate),QT_TRANSLATE_NOOP("nvenc","Max Bitrate (kbps):"),1,50000);
          /* First Tab : encoding mode */
        diaElem *diamode[]={&qzPreset,&bitrate,&maxBitrate};

        if( diaFactoryRun(QT_TRANSLATE_NOOP("nvenc","Nvidia H264 Encoder configuration"),3,diamode))
        {
          
          return true;
        }
         return false;
}

bool ffVAEncHevcConfigure(void)
{
    ffvaHEVC_encoder *conf=&VaEncHevcSettings;

#define PX(x) &(conf->x)

    diaElemUInteger gopSize(PX(gopsize),QT_TRANSLATE_NOOP("ffVAEncHEVC","GOP Size:"),1,250);

    diaElemUInteger maxBframes(PX(bframes),QT_TRANSLATE_NOOP("ffVAEncHEVC","Maximum Consecutive B-Frames:"),0,4);
    diaElemUInteger bitrate(PX(bitrate), QT_TRANSLATE_NOOP("ffVAEncHEVC","Bitrate (kbps):"),1,50000);
    diaElemUInteger maxBitrate(PX(max_bitrate), QT_TRANSLATE_NOOP("ffVAEncHEVC","Max Bitrate (kbps):"),1,50000);
    diaElemFrame rateControl(QT_TRANSLATE_NOOP("ffVAEncHEVC","Rate Control"));
    diaElemFrame frameControl(QT_TRANSLATE_NOOP("ffVAEncHEVC","Frame Control"));

    rateControl.swallow(&bitrate);
    rateControl.swallow(&maxBitrate);
    frameControl.swallow(&gopSize);
    frameControl.swallow(&maxBframes);

    diaElem *diamode[] = {&rateControl,&frameControl};

    if( diaFactoryRun(QT_TRANSLATE_NOOP("ffVAEncHEVC","FFmpeg VA-API HEVC Encoder Configuration"),2,diamode))
    {
        return true;
    }
    return false;
}

void PX(split_cart_procmesh_for_3dto2d_remap_q1)(
    const INT *n, MPI_Comm comm_cart_3d,
    MPI_Comm *comm_1d
    )
{
  int p0, p1, q0=0, q1=0;
  int ndims, coords_3d[3];
  int dim_1d, period_1d, reorder=0;
  int color, key;
  MPI_Comm comm;

  if( !PX(is_cart_procmesh)(comm_cart_3d) )
    return;

  MPI_Cartdim_get(comm_cart_3d, &ndims);
  if(ndims != 3)
    return;

  PX(get_mpi_cart_coords)(comm_cart_3d, ndims, coords_3d);
  PX(get_procmesh_dims_2d)(n, comm_cart_3d, &p0, &p1, &q0, &q1);

  /* split into p0*p1*q0 comms of size q1 */
  color = coords_3d[0]*p1*q0 + coords_3d[1]*q0 + coords_3d[2]/q1;
  key = coords_3d[2]%q1;
//   key = coords_3d[2]/q0; /* TODO: delete this line after several tests */
  MPI_Comm_split(comm_cart_3d, color, key, &comm);

  dim_1d = q1; period_1d = 1;
  MPI_Cart_create(comm, ndims=1, &dim_1d, &period_1d, reorder,
      comm_1d);

  MPI_Comm_free(&comm);
}

uint8_t DGbob::configure(AVDMGenericVideoStream *in)
{
        _in=in;
#define PX(x) &(_param->x)
  
     diaMenuEntry menuField[2]={{0,QT_TR_NOOP("Top"),NULL},
                             {1,QT_TR_NOOP("Bottom"),NULL}
                          };
  
     diaMenuEntry menuMode[3]={{0,QT_TR_NOOP("Keep nb of frames and fps"),NULL},
                            {1,QT_TR_NOOP("Double nb of frames and fps"),NULL},
                            {2,QT_TR_NOOP("Double nb of frames (slow motion)"),NULL}
                          };
                          
    diaElemMenu     menu1(PX(order),QT_TR_NOOP("_Field order:"), 2,menuField);
    diaElemMenu     menu2(PX(mode),QT_TR_NOOP("_Mode:"), 3,menuMode);
    diaElemUInteger threshold(PX(thresh),QT_TR_NOOP("_Threshold:"),0,255);
    diaElemToggle  extra(PX(ap),QT_TR_NOOP("_Extra"),QT_TR_NOOP("Extra check, avoid using it"));
    
      diaElem *elems[4]={&menu1,&menu2,&threshold ,&extra};
   if(diaFactoryRun(QT_TR_NOOP("DGBob"),4,elems))
  {
                update();
                return 1;
        }
        return 0;
        
}

/**
      \fn DIA_animated
      \brief Dialog to set params for the animated filter
*/
uint8_t DIA_animated(ANIMATED_PARAM *param,uint32_t w, uint32_t h,uint32_t n)
{	
  uint8_t r=0;
#define PX(x) &(param->x)
   diaElemFile      jpeg(0,(char **)PX(backgroundImg),QT_TR_NOOP("_Background Image:"), NULL, QT_TR_NOOP("Select background image"));
   diaElemToggle    isNtsc(PX(isNTSC),QT_TR_NOOP("_NTSC (default is PAL):"));
   diaElemUInteger   vignetteW(PX(vignetteW),QT_TR_NOOP("Vignette _Width:"),16,w/3);
   diaElemUInteger   vignetteH(PX(vignetteH),QT_TR_NOOP("Vignette _Height:"),16,h/2);
   
   diaElemUInteger *timecode[MAX_VIGNETTE];
   diaElemFrame timecodes(QT_TR_NOOP("Vignette frame number"));

   for(int i=0;i<MAX_VIGNETTE;i++)
   {
     timecode[i]=new diaElemUInteger(&(param->timecode[i]),QT_TR_NOOP("Timecode:"),0,n);
     timecodes.swallow(timecode[i]);
   }

 
      diaElem *elems[5]={&jpeg,&isNtsc,&vignetteW,&vignetteH,&timecodes};
    
  if( diaFactoryRun(QT_TR_NOOP("Animated Menu"),5,elems))
  {
    r=1;
  }
  for(int i=0;i<MAX_VIGNETTE;i++)
  {
    delete timecode[i]; 
  }
  
  return r;
}	

uint8_t ADMVideoMPD3Dlow::configure(AVDMGenericVideoStream *instream)
{

        _in=instream;
        ELEM_TYPE_FLOAT fluma,fchroma,ftemporal;
#define PX(x) &x
#define OOP(x,y) f##x=(ELEM_TYPE_FLOAT )_param->y;
        
        OOP(luma,param1);
        OOP(chroma,param2);
        OOP(temporal,param3);
        
    diaElemFloat   luma(PX(fluma),QT_TR_NOOP("_Spatial luma strength:"),0.,100.);
    diaElemFloat   chroma(PX(fchroma),QT_TR_NOOP("S_patial chroma strength:"),0.,100.);
    diaElemFloat   temporal(PX(ftemporal),QT_TR_NOOP("_Temporal strength:"),0.,100.);
    
       diaElem *elems[3]={&luma,&chroma,&temporal};
  
   if(  diaFactoryRun(QT_TR_NOOP("MPlayer denoise3d"),3,elems))
        {
#undef OOP
#define OOP(x,y) _param->y=(double) f##x
                OOP(luma,param1);
                OOP(chroma,param2);
                OOP(temporal,param3);
          
                setup();
                return 1;
        }
        return 0;
}

    SuggestionWidget(wxWindow *parent) : wxPanel(parent, wxID_ANY)
    {
        m_appIsRTL = (wxTheApp->GetLayoutDirection() == wxLayout_RightToLeft);

        m_icon = new wxStaticBitmap(this, wxID_ANY, wxNullBitmap);
        m_text = new AutoWrappingText(this, "TEXT");
        m_info = new InfoStaticText(this);

        auto top = new wxBoxSizer(wxHORIZONTAL);
        auto right = new wxBoxSizer(wxVERTICAL);
        top->AddSpacer(PX(2));
        top->Add(m_icon, wxSizerFlags().Top().PXBorder(wxTOP|wxBOTTOM));
        top->Add(right, wxSizerFlags(1).Expand().PXBorder(wxLEFT));
        right->Add(m_text, wxSizerFlags().Expand().Border(wxTOP, PX(4)));
        right->Add(m_info, wxSizerFlags().Expand().Border(wxTOP|wxBOTTOM, PX(2)));
        SetSizerAndFit(top);

        // setup mouse hover highlighting:
        m_bg = parent->GetBackgroundColour();
        m_bgHighlight = m_bg.ChangeLightness(160);

        wxWindow* parts [] = { this, m_icon, m_text, m_info };
        for (auto w : parts)
        {
            w->Bind(wxEVT_MOTION,       &SuggestionWidget::OnMouseMove, this);
            w->Bind(wxEVT_LEAVE_WINDOW, &SuggestionWidget::OnMouseMove, this);
            w->Bind(wxEVT_LEFT_UP,      &SuggestionWidget::OnMouseClick, this);
        }
    }

 void OnPaint(wxPaintEvent&)
 {
     wxPaintDC dc(this);
     auto w = dc.GetSize().x;
     dc.GradientFillLinear(wxRect(0,0,PX(15),PX(1)), m_sides, m_center);
     dc.GradientFillLinear(wxRect(PX(15),0,w,PX(1)), m_center, m_sides);
 }

static INT num_used_procs(
    INT N, int p
    )
{
  INT blk = PX(global_block_size)(N, PFFT_DEFAULT_BLOCK, p);
  return PX(num_blocks)(N, blk);
}

/**
    \fn configure
*/
bool lavDeint::configure( void)
{

  #define PX(x) &(param.x)
   diaMenuEntry menuField[6]={{PP_BM_NONE,        QT_TRANSLATE_NOOP("lavdeint","None"),NULL},
                             {PP_BM_LINEAR_BLEND, QT_TRANSLATE_NOOP("lavdeint","Linear blend"),NULL},
                             {PP_BM_LINEAR_INTER, QT_TRANSLATE_NOOP("lavdeint","Linear interpolate"),NULL},
                             {PP_BM_CUBIC_INTER,  QT_TRANSLATE_NOOP("lavdeint","Cubic interpolate"),NULL},
                             {PP_BM_MEDIAN_INTER, QT_TRANSLATE_NOOP("lavdeint","Median interpolate"),NULL},
                             {PP_BM_FFMPEG_DEINT, QT_TRANSLATE_NOOP("lavdeint","FFmpeg deint"),NULL},
                          };
  
    
    diaElemMenu     menu1(PX(deintType),QT_TRANSLATE_NOOP("lavdeint","_Deinterlacing:"), 6,menuField);
    diaElemToggle   autolevel(PX(autoLevel),QT_TRANSLATE_NOOP("lavdeint","_Autolevel"));
    
    diaElem *elems[2]={&menu1,&autolevel};
  
   if(diaFactoryRun(QT_TRANSLATE_NOOP("lavdeint","libavcodec deinterlacer"),2,elems))
  {
    setup();
    return true; 
  }
  return false;        
}

//*************************************************************
uint8_t ADMVideoLavPPDeint::configure(AVDMGenericVideoStream *in)
{

  #define PX(x) &(_param->x)
  _in=in;
  
  
   diaMenuEntry menuField[6]={{PP_BM_NONE,        QT_TR_NOOP("None"),NULL},
                             {PP_BM_LINEAR_BLEND, QT_TR_NOOP("Linear blend"),NULL},
                             {PP_BM_LINEAR_INTER, QT_TR_NOOP("Linear interpolate"),NULL},
                             {PP_BM_CUBIC_INTER, QT_TR_NOOP("Cubic interpolate"),NULL},
                             {PP_BM_MEDIAN_INTER, QT_TR_NOOP("Median interpolate"),NULL},
                             {PP_BM_FFMPEG_DEINT, QT_TR_NOOP("FFmpeg deint"),NULL},
                          };
  
    
    diaElemMenu     menu1(PX(deintType),QT_TR_NOOP("_Deinterlacing:"), 6,menuField);
    diaElemToggle   autolevel(PX(autolevel),QT_TR_NOOP("_Autolevel"));
    
    diaElem *elems[2]={&menu1,&autolevel};
  
   if(diaFactoryRun(QT_TR_NOOP("libavcodec deinterlacer"),2,elems))
  {
    setup();
    return 1; 
  }
  return 0;        
}

void PX(local_block_size_and_offset)(INT global_array_size, INT global_block_size, int which_block,
    INT *local_block_size, INT *local_block_start)
{
  /* Block index runs from blockStart <= index < blockEnd */

  *local_block_start = PX(local_block_offset)(global_array_size, global_block_size, which_block);
  *local_block_size  = PX(local_block_size)(global_array_size, global_block_size, which_block);
}

PX(plan) PX(plan_dft_c2r_3d_f03)(const INT * Nos, C * in, R * out, MPI_Fint f_comm_cart, int sign, unsigned pfft_flags)
{
  MPI_Comm comm_cart;

  comm_cart = MPI_Comm_f2c(f_comm_cart);
  PX(plan) ret = PX(plan_dft_c2r_3d)(Nos, in, out, comm_cart, sign, pfft_flags);
  return ret;
}

bool avsfilter::configure(void)
{
 DEBUG_PRINTF("avsfilter : before dialog init\n");
 print_objects();

#define PX(x) &(param.x)
 diaElemFile wine_app(0,(char**)PX(wine_app),
                      QT_TR_NOOP("_wine app file:"), NULL,
                      QT_TR_NOOP("Select wine filename[wine/cedega/etc.]"));
 diaElemFile loaderfile(0,(char**)PX(avs_loader),
                        QT_TR_NOOP("_loader file:"), NULL,
                        QT_TR_NOOP("Select loader filename[avsload.exe]"));
 diaElemFile avsfile(0,(char**)PX(avs_script),
                     QT_TR_NOOP("_avs file:"), NULL,
                     QT_TR_NOOP("Select avs filename[*.avs]"));
 diaElemUInteger pipe_timeout(PX(pipe_timeout),QT_TR_NOOP("_pipe timeout:"),1,30);

 diaElem *elems[4]={&wine_app, &loaderfile, &avsfile, &pipe_timeout};

 if( diaFactoryRun(QT_TR_NOOP("AvsFilter config"), 4, elems))
 {
  bool res = false;

  DEBUG_PRINTF("avsfilter : configure before SetParameters\n");

  // if script/loader names are exist, then taste config
  if (param.avs_loader && strlen((const char*)param.avs_loader) &&
      param.avs_script && strlen((const char*)param.avs_script) &&
      param.wine_app && strlen((const char*)param.wine_app))
  {
   struct stat st;
   if (stat((char*)param.avs_script, &st) != 0)
   {
    DEBUG_PRINTF_RED("avsfilter : cannot stat script file\n");
    return 0;
   }

   param.script_mtime = st.st_mtime; // store timestamp
   param.script_ctime = st.st_ctime;

   print_objects();
   res = SetParameters(&param);
   if (res)
    avsfilter_config_jserialize(prefs_name, &param);

   DEBUG_PRINTF("avsfilter : configure before save prefs [%s][%s]\n",
                param.avs_script, param.avs_loader);
   // if setparameters are ok and (therefore) avs_script and avs_loader exist
   // we store this parameters in filter preferences
   DEBUG_PRINTF("avsfilter : after save prefs info : frameIncrement %lu totalDuration %llu\n",
                info.frameIncrement, info.totalDuration);

   DEBUG_PRINTF("avsfilter : configure exit ok\n");
   return res;
  }
 }
 return 0;
}

uint8_t ADMVideoKernelDeint::configure( AVDMGenericVideoStream *instream)
{
	_in=instream;
	#define PX(x) &_param->x
	if(DIA_kerneldeint(PX(order), PX(threshold), PX(sharp), 
		PX(twoway), PX(map)))
					return 1;
	return 0;	
 	
}

 OldMsgidSidebarBlock(Sidebar *parent)
       /// TRANSLATORS: "Previous" as in used in the past, now replaced with newer.
     : SidebarBlock(parent, _("Previous source text:"))
 {
     m_innerSizer->AddSpacer(PX(2));
     m_innerSizer->Add(new ExplanationLabel(parent, _("The old source text (before it changed during an update) that the fuzzy translation corresponds to.")),
                  wxSizerFlags().Expand());
     m_innerSizer->AddSpacer(PX(5));
     m_text = new SelectableAutoWrappingText(parent, "");
     m_innerSizer->Add(m_text, wxSizerFlags().Expand());
 }

static void get_local_start_3d(
    const INT *n, const INT *blks, const MPI_Comm *comms,
    INT *local_start
    )
{
  int coord;

  for(int t=0; t<3; t++){
    PX(get_mpi_cart_coord_1d)(comms[t], &coord);
    local_start[t] = PX(local_block_offset)(n[t], blks[t], coord);
  }
}

	bool SnakeLayer::init()
	{
		maximumLength = 100;
		itemsPicked = 0;
		score = 0;
		bonus = 0;
		direction = Point::ZERO;
		speed = 180;

		LayerColor* lc = LayerColor::create(Color4B(0, 0, 0, 210), PX(1.0f), PY(0.8f));
		lc->setPosition(CP(0.5f, 0.5f));
		lc->setAnchorPoint(Point(0.5f, 0.5f));
		lc->ignoreAnchorPointForPosition(false);
		addChild(lc);
		bounds = lc->getBoundingBox();

		LayerColor* scorebg = LayerColor::create(Color4B::BLACK, PX(1.0f), PY(0.1f));
		scorebg->setPosition(Point::ZERO);
		addChild(scorebg);

		addChild(lineGroup = Node::create());
		addChild(bonusGroup = Node::create());
		addChild(itemGroup = Node::create());

		LineNode* line = LineNode::create(CP(0.5f, 0.5f), CP(0.5f, 0.5f));
		lineGroup->addChild(line);

		schedule(schedule_selector(SnakeLayer::considerSpawningBonus), 5.0f);
		scheduleUpdate();

		lblScore = Label::createWithTTF(LS("ScoreColon") + " 0", NORMAL_TTF, 42.0f);
		lblScore->setColor(Color3B::WHITE);
		lblScore->setPosition(CP(0.5f, 0.05f));
		//lblScore->enableGlow(Color4B::BLACK);
		//lblScore->enableShadow(Color4B::BLACK, Size::ZERO, 4);
		addChild(lblScore);

		string instruction = LS("SNAKE_INSTRUCTIONS");
		lblInstruction = Label::createWithTTF(instruction, NORMAL_TTF, 48.0f);
		lblInstruction->setPosition(CP(0.5f, 0.5f));
		lblInstruction->setHorizontalAlignment(TextHAlignment::CENTER);
		lblInstruction->setColor(Color3B::WHITE);
		lblInstruction->enableGlow(Color4B::RED);
		lblInstruction->runAction(RepeatForever::create(
			Sequence::createWithTwoActions(ScaleTo::create(1.0f, 1.1f),
			ScaleTo::create(1.0f, 1.0f))));
		addChild(lblInstruction);
		instructionVisible = true;

		return true;
	}

void re_basics() {
    double euro_cent;
    PX(my::euro_parser("1,89", euro_cent));         PX(euro_cent);
    PX(my::euro_parser("123,89", euro_cent));       PX(euro_cent);
    PX(my::euro_parser("1234567,89", euro_cent));   PX(euro_cent);
    PX(my::euro_parser("1.234.567,89", euro_cent)); PX(euro_cent);
}