Пример #1
0
static int coco_load(struct module_data *m, FILE *f, const int start)
{
	struct xmp_module *mod = &m->mod;
	struct xmp_event *event;
	int i, j;
	int seq_ptr, pat_ptr, smp_ptr[100];

	LOAD_INIT();

	mod->chn = read8(f) & 0x3f;
	read_title(f, mod->name, 20);

	for (i = 0; i < 20; i++) {
		if (mod->name[i] == 0x0d)
			mod->name[i] = 0;
	}

	set_type(m, "Coconizer");

	mod->ins = mod->smp = read8(f);
	mod->len = read8(f);
	mod->pat = read8(f);
	mod->trk = mod->pat * mod->chn;

	seq_ptr = read32l(f);
	pat_ptr = read32l(f);

	MODULE_INFO();
	INSTRUMENT_INIT();

	m->vol_table = (int *)arch_vol_table;
	m->volbase = 0xff;

	for (i = 0; i < mod->ins; i++) {
		mod->xxi[i].sub = calloc(sizeof (struct xmp_subinstrument), 1);

		smp_ptr[i] = read32l(f);
		mod->xxs[i].len = read32l(f);
		mod->xxi[i].sub[0].vol = 0xff - read32l(f);
		mod->xxi[i].sub[0].pan = 0x80;
		mod->xxs[i].lps = read32l(f);
                mod->xxs[i].lpe = mod->xxs[i].lps + read32l(f);
		if (mod->xxs[i].lpe)
			mod->xxs[i].lpe -= 1;
		mod->xxs[i].flg = mod->xxs[i].lps > 0 ?  XMP_SAMPLE_LOOP : 0;
		fread(mod->xxi[i].name, 1, 11, f);
		for (j = 0; j < 11; j++) {
			if (mod->xxi[i].name[j] == 0x0d)
				mod->xxi[i].name[j] = 0;
		}
		read8(f);	/* unused */

		mod->xxi[i].nsm = !!mod->xxs[i].len;
		mod->xxi[i].sub[0].sid = i;

		D_(D_INFO "[%2X] %-10.10s  %05x %05x %05x %c V%02x",
				i, mod->xxi[i].name,
				mod->xxs[i].len, mod->xxs[i].lps, mod->xxs[i].lpe,
				mod->xxs[i].flg & XMP_SAMPLE_LOOP ? 'L' : ' ',
				mod->xxi[i].sub[0].vol);
	}

	/* Sequence */

	fseek(f, start + seq_ptr, SEEK_SET);
	for (i = 0; ; i++) {
		uint8 x = read8(f);
		if (x == 0xff)
			break;
		mod->xxo[i] = x;
	}
	for (i++; i % 4; i++)	/* for alignment */
		read8(f);


	/* Patterns */

	PATTERN_INIT();

	D_(D_INFO "Stored patterns: %d", mod->pat);

	for (i = 0; i < mod->pat; i++) {
		PATTERN_ALLOC (i);
		mod->xxp[i]->rows = 64;
		TRACK_ALLOC (i);

		for (j = 0; j < (64 * mod->chn); j++) {
			event = &EVENT (i, j % mod->chn, j / mod->chn);
			event->fxp = read8(f);
			event->fxt = read8(f);
			event->ins = read8(f);
			event->note = read8(f);
			if (event->note)
				event->note += 12;

			fix_effect(event);
		}
	}

	/* Read samples */

	D_(D_INFO "Stored samples : %d", mod->smp);

	for (i = 0; i < mod->ins; i++) {
		if (mod->xxi[i].nsm == 0)
			continue;

		fseek(f, start + smp_ptr[i], SEEK_SET);
		load_sample(f, SAMPLE_FLAG_VIDC, &mod->xxs[mod->xxi[i].sub[0].sid], NULL);
	}

	for (i = 0; i < mod->chn; i++)
		mod->xxc[i].pan = (((i + 3) / 2) % 2) * 0xff;

	return 0;
}
Пример #2
0
static int hsc_load(struct module_data *m, HIO_HANDLE *f, const int start)
{
    struct xmp_module *mod = &m->mod;
    int pat, i, r, c;
    struct xmp_event *event;
    uint8 *x, *sid, e[2], buf[128 * 12];

    LOAD_INIT();

    hio_read(buf, 1, 128 * 12, f);

    x = buf;
    for (i = 0; i < 128; i++, x += 12) {
	if (x[9] & ~0x3 || x[10] & ~0x3)	/* Test waveform register */
	    break;
	if (x[8] & ~0xf)			/* Test feedback & algorithm */
	    break;
    }

    mod->ins = i;

    hio_seek(f, start + 0, SEEK_SET);

    mod->chn = 9;
    mod->bpm = 135;
    mod->spd = 6;
    mod->smp = mod->ins;

    m->quirk |= QUIRK_LINEAR;

    set_type(m, "HSC-Tracker");

    MODULE_INFO();

    /* Read instruments */
    if (instrument_init(mod) < 0)
	return -1;

    hio_read (buf, 1, 128 * 12, f);
    sid = buf;
    for (i = 0; i < mod->ins; i++, sid += 12) {
	if (subinstrument_alloc(mod, i, 1) < 0)
	    return -1;

	mod->xxi[i].nsm = 1;
	mod->xxi[i].sub[0].vol = 0x40;
	mod->xxi[i].sub[0].fin = (int8)sid[11] / 4;
	mod->xxi[i].sub[0].pan = 0x80;
	mod->xxi[i].sub[0].xpo = 0;
	mod->xxi[i].sub[0].sid = i;
	mod->xxi[i].rls = LSN(sid[7]) * 32;	/* carrier release */

	if (load_sample(m, f, SAMPLE_FLAG_ADLIB | SAMPLE_FLAG_HSC,
					&mod->xxs[i], (char *)sid) < 0)
		return -1;
    }

    /* Read orders */
    for (pat = i = 0; i < 51; i++) {
	hio_read (&mod->xxo[i], 1, 1, f);
	if (mod->xxo[i] & 0x80)
	    break;			/* FIXME: jump line */
	if (mod->xxo[i] > pat)
	    pat = mod->xxo[i];
    }
    hio_seek(f, 50 - i, SEEK_CUR);
    mod->len = i;
    mod->pat = pat + 1;
    mod->trk = mod->pat * mod->chn;

    D_(D_INFO "Module length: %d", mod->len);
    D_(D_INFO "Instruments: %d", mod->ins);
    D_(D_INFO "Stored patterns: %d", mod->pat);

    if (pattern_init(mod) < 0)
	return -1;

    /* Read and convert patterns */
    for (i = 0; i < mod->pat; i++) {
	int ins[9] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };

	if (pattern_tracks_alloc(mod, i, 64) < 0)
	    return -1;

        for (r = 0; r < mod->xxp[i]->rows; r++) {
            for (c = 0; c < 9; c++) {
	        hio_read (e, 1, 2, f);
	        event = &EVENT (i, c, r);
		if (e[0] & 0x80) {
		    ins[c] = e[1] + 1;
		} else if (e[0] == 0x7f) {
		    event->note = XMP_KEY_OFF;
		} else if (e[0] > 0) {
		    event->note = e[0] + 25;
		    event->ins = ins[c];
		}

		event->fxt = 0;
		event->fxp = 0;

		if (e[1] == 0x01) {
		    event->fxt = 0x0d;
		    event->fxp = 0;
		}
	    }
	}
    }

    for (i = 0; i < mod->chn; i++) {
	mod->xxc[i].pan = 0x80;
	mod->xxc[i].flg = XMP_CHANNEL_SYNTH;
    }

    m->synth = &synth_adlib;

    return 0;
}
Пример #3
0
static const char *
_gc_label (const E_Gadcon_Client_Class *client_class)
{
   return D_ ("Empris");
}
Пример #4
0
static void
_mpdule_update_song (Instance * inst)
{
  mpd_Connection *mpd;
  Evas_Object *mpdule;
  Evas_Object *o_popup;

  if (!inst->mpd)
    return;
  mpd = inst->mpd;
  mpdule = inst->mpdule;
  o_popup = inst->o_popup;
  mpd_sendStatusCommand (mpd);
  if (mpd->error == 0)
    {
      mpd_Status *status = mpd_getStatus (mpd);

      if (status)
	{
	  if (status->state == MPD_STATUS_STATE_UNKNOWN)
	    {
	      edje_object_part_text_set (mpdule, "mpdule.status",
					 D_ ("Unknown"));
	      edje_object_part_text_set (o_popup, "mpdule.status",
					 D_ ("Unknown"));
	    }
	  else if (status->state == MPD_STATUS_STATE_STOP)
	    {
	      edje_object_part_text_set (mpdule, "mpdule.status",
					 D_ ("Stopped"));
	      edje_object_part_text_set (o_popup, "mpdule.status",
					 D_ ("Stopped"));
	    }
	  else if (status->state == MPD_STATUS_STATE_PLAY)
	    {
	      edje_object_part_text_set (mpdule, "mpdule.status",
					 D_ ("Playing"));
	      edje_object_part_text_set (o_popup, "mpdule.status",
					 D_ ("Playing"));
	    }
	  else if (status->state == MPD_STATUS_STATE_PAUSE)
	    {
	      edje_object_part_text_set (mpdule, "mpdule.status",
					 D_ ("Paused"));
	      edje_object_part_text_set (o_popup, "mpdule.status",
					 D_ ("Paused"));
	    }

	  if (status->state > MPD_STATUS_STATE_STOP)
	    {
	      mpd_sendCurrentSongCommand (mpd);
	      mpd_InfoEntity *entity = NULL;

	      while ((entity = mpd_getNextInfoEntity (mpd)))
		{
		  if (entity->type == MPD_INFO_ENTITY_TYPE_SONG &&
		      entity->info.song->id == status->songid)
		    {
		      mpd_Song *song = entity->info.song;

		      if (song->artist)
			{
			  edje_object_part_text_set (mpdule, "mpdule.artist",
						     song->artist);
			  edje_object_part_text_set (o_popup, "mpdule.artist",
						     song->artist);
			}
		      else
			{
			  edje_object_part_text_set (mpdule, "mpdule.artist",
						     "");
			  edje_object_part_text_set (o_popup, "mpdule.artist",
						     "");
			}
		      if (song->title)
			{
			  edje_object_part_text_set (mpdule, "mpdule.title",
						     song->title);
			  edje_object_part_text_set (o_popup, "mpdule.title",
						     song->title);
			}
		      else
			{
			  edje_object_part_text_set (mpdule, "mpdule.title",
						     "");
			  edje_object_part_text_set (o_popup, "mpdule.title",
						     "");
			}
		      if (song->album)
			{
			  edje_object_part_text_set (mpdule, "mpdule.album",
						     song->album);
			  edje_object_part_text_set (o_popup, "mpdule.album",
						     song->album);
			}
		      else
			{
			  edje_object_part_text_set (mpdule, "mpdule.album",
						     "");
			  edje_object_part_text_set (o_popup, "mpdule.album",
						     "");
			}
		      if (song->track)
			{
			  edje_object_part_text_set (mpdule, "mpdule.track",
						     song->track);
			  edje_object_part_text_set (o_popup, "mpdule.track",
						     song->track);
			}
		      else
			{
			  edje_object_part_text_set (mpdule, "mpdule.track",
						     "");
			  edje_object_part_text_set (o_popup, "mpdule.track",
						     "");
			}
		      if (song->date)
			{
			  edje_object_part_text_set (mpdule, "mpdule.date",
						     song->date);
			  edje_object_part_text_set (o_popup, "mpdule.date",
						     song->date);
			}
		      else
			{
			  edje_object_part_text_set (mpdule, "mpdule.date",
						     "");
			  edje_object_part_text_set (o_popup, "mpdule.date",
						     "");
			}
		      if (song->genre)
			{
			  edje_object_part_text_set (mpdule, "mpdule.genre",
						     song->genre);
			  edje_object_part_text_set (o_popup, "mpdule.genre",
						     song->genre);
			}
		      else
			{
			  edje_object_part_text_set (mpdule, "mpdule.genre",
						     "");
			  edje_object_part_text_set (o_popup, "mpdule.genre",
						     "");
			}
		      if (song->composer)
			{
			  edje_object_part_text_set (mpdule,
						     "mpdule.composer",
						     song->composer);
			  edje_object_part_text_set (o_popup,
						     "mpdule.composer",
						     song->composer);
			}
		      else
			{
			  edje_object_part_text_set (mpdule,
						     "mpdule.composer", "");
			  edje_object_part_text_set (o_popup,
						     "mpdule.composer", "");
			}
		      if (song->time)
			{
			  //char * songtime;
			  //sprintf(songtime, "%i", song->time);
			  //edje_object_part_text_set (mpdule, "mpdule.time", songtime);
			  //edje_object_part_text_set (o_popup, "mpdule.time", songtime);
			}
		      else
			{
			  edje_object_part_text_set (mpdule, "mpdule.time",
						     "");
			  edje_object_part_text_set (o_popup, "mpdule.time",
						     "");
			}
		      if (song->file)
			{
			  edje_object_part_text_set (mpdule, "mpdule.file",
						     song->file);
			  edje_object_part_text_set (o_popup, "mpdule.file",
						     song->file);
			}
		      else
			{
			  edje_object_part_text_set (mpdule, "mpdule.file",
						     "");
			  edje_object_part_text_set (o_popup, "mpdule.file",
						     "");
			}
		    }

		  mpd_freeInfoEntity (entity);
		}
	    }

	  mpd_freeStatus (status);
	}
    }
  else
    {
      _mpdule_disconnect (inst);
      _mpdule_connect (inst);
    }
}
Пример #5
0
void __attribute__((constructor)) swh_init() {
    char **port_names;
    LADSPA_PortDescriptor *port_descriptors;
    LADSPA_PortRangeHint *port_range_hints;

#ifdef ENABLE_NLS
#define D_(s) dgettext(PACKAGE, s)
    setlocale(LC_ALL, "");
    bindtextdomain(PACKAGE, PACKAGE_LOCALE_DIR);
#else
#define D_(s) (s)
#endif


    impulse_fcDescriptor =
        (LADSPA_Descriptor *)malloc(sizeof(LADSPA_Descriptor));

    if (impulse_fcDescriptor) {
        impulse_fcDescriptor->UniqueID = 1885;
        impulse_fcDescriptor->Label = "impulse_fc";
        impulse_fcDescriptor->Properties =
            LADSPA_PROPERTY_HARD_RT_CAPABLE;
        impulse_fcDescriptor->Name =
            D_("Nonbandlimited single-sample impulses (Frequency: Control)");
        impulse_fcDescriptor->Maker =
            "Andy Wingo <wingo at pobox dot com>";
        impulse_fcDescriptor->Copyright =
            "GPL";
        impulse_fcDescriptor->PortCount = 2;

        port_descriptors = (LADSPA_PortDescriptor *)calloc(2,
                           sizeof(LADSPA_PortDescriptor));
        impulse_fcDescriptor->PortDescriptors =
            (const LADSPA_PortDescriptor *)port_descriptors;

        port_range_hints = (LADSPA_PortRangeHint *)calloc(2,
                           sizeof(LADSPA_PortRangeHint));
        impulse_fcDescriptor->PortRangeHints =
            (const LADSPA_PortRangeHint *)port_range_hints;

        port_names = (char **)calloc(2, sizeof(char*));
        impulse_fcDescriptor->PortNames =
            (const char **)port_names;

        /* Parameters for Frequency (Hz) */
        port_descriptors[IMPULSE_FC_FREQUENCY] =
            LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
        port_names[IMPULSE_FC_FREQUENCY] =
            D_("Frequency (Hz)");
        port_range_hints[IMPULSE_FC_FREQUENCY].HintDescriptor =
            LADSPA_HINT_BOUNDED_BELOW;
        port_range_hints[IMPULSE_FC_FREQUENCY].LowerBound = 0;

        /* Parameters for Output */
        port_descriptors[IMPULSE_FC_OUT] =
            LADSPA_PORT_OUTPUT | LADSPA_PORT_AUDIO;
        port_names[IMPULSE_FC_OUT] =
            D_("Output");
        port_range_hints[IMPULSE_FC_OUT].HintDescriptor = 0;

        impulse_fcDescriptor->activate = activateImpulse_fc;
        impulse_fcDescriptor->cleanup = cleanupImpulse_fc;
        impulse_fcDescriptor->connect_port = connectPortImpulse_fc;
        impulse_fcDescriptor->deactivate = NULL;
        impulse_fcDescriptor->instantiate = instantiateImpulse_fc;
        impulse_fcDescriptor->run = runImpulse_fc;
        impulse_fcDescriptor->run_adding = runAddingImpulse_fc;
        impulse_fcDescriptor->set_run_adding_gain = setRunAddingGainImpulse_fc;
    }
}
void
ngi_border_menu_show(Ngi_Box *box, E_Border *bd, Evas_Coord x, Evas_Coord y, int dir, Ecore_X_Time timestamp)
{
   E_Menu *m;
   E_Menu_Item *mi;
   Ng *ng = box->ng;

   if (bd->border_menu)
      return;

   m = e_menu_new();
   e_menu_category_set(m,"border");
   e_menu_category_data_set("border",bd);
   e_object_data_set(E_OBJECT(m), bd);
   bd->border_menu = m;
   e_menu_post_deactivate_callback_set(m, _ng_border_cb_border_menu_end, ng); /* FIXME */

   if ((!bd->lock_user_fullscreen) && (!bd->shaded))
     {
        mi = e_menu_item_new(m);
        e_menu_item_label_set(mi, D_("Fullscreen"));
        e_menu_item_check_set(mi, 1);
        e_menu_item_toggle_set(mi, bd->fullscreen);
        e_menu_item_callback_set(mi, _ng_border_menu_cb_fullscreen, bd);
        e_menu_item_icon_edje_set(mi,
                                  e_theme_edje_file_get("base/theme/borders",
                                                        "e/widgets/border/default/fullscreen"),
                                  "e/widgets/border/default/fullscreen");
     }

   mi = e_menu_item_new(m);
   e_menu_item_separator_set(mi, 1);
   if (!bd->lock_close)
     {
        mi = e_menu_item_new(m);
        e_menu_item_label_set(mi, D_("Close"));
        e_menu_item_callback_set(mi, _ng_border_menu_cb_close, bd);
        e_menu_item_icon_edje_set(mi,
                                  e_theme_edje_file_get("base/theme/borders",
                                                        "e/widgets/border/default/close"),
                                  "e/widgets/border/default/close");
     }

   if (!bd->internal)
     {
        mi = e_menu_item_new(m);
        e_menu_item_separator_set(mi, 1);

        if (!(((bd->client.icccm.min_w == bd->client.icccm.max_w) &&
               (bd->client.icccm.min_h == bd->client.icccm.max_h)) ||
              (bd->lock_user_maximize)))
          {
             if ((!bd->lock_user_maximize) && (!bd->shaded) &&
                 ((bd->layer == 50) || (bd->layer == 100) || (bd->layer == 150)))
               {
                  mi = e_menu_item_new(m);
                  e_menu_item_label_set(mi, D_("Maximized"));
                  e_menu_item_check_set(mi, 1);
                  e_menu_item_toggle_set(mi, (bd->maximized & E_MAXIMIZE_DIRECTION) == E_MAXIMIZE_BOTH);
                  if((bd->maximized & E_MAXIMIZE_DIRECTION) == E_MAXIMIZE_BOTH)
                     e_menu_item_callback_set(mi, _ng_border_menu_cb_unmaximize, bd);
                  else
                     e_menu_item_callback_set(mi, _ng_border_menu_cb_maximize, bd);

                  e_menu_item_icon_edje_set(mi,
                                            e_theme_edje_file_get("base/theme/borders",
                                                                  "e/widgets/border/default/maximize"),
                                            "e/widgets/border/default/maximize");
               }
          }
     }

   if (!bd->lock_user_iconify)
     {
        mi = e_menu_item_new(m);
        if(bd->iconic)
           e_menu_item_label_set(mi, D_("Uniconify"));
        else
           e_menu_item_label_set(mi, D_("Iconify"));

        e_menu_item_callback_set(mi, _ng_border_menu_cb_iconify, bd);
        e_menu_item_icon_edje_set(mi,
                                  e_theme_edje_file_get("base/theme/borders",
                                                        "e/widgets/border/default/minimize"),
                                  "e/widgets/border/default/minimize");
     }

   e_menu_activate_mouse(m, ng->zone, ng->zone->x + x, ng->zone->y + y, 1, 1,
                         dir, timestamp);
}
Пример #7
0
void _init() {
	char **port_names;
	LADSPA_PortDescriptor *port_descriptors;
	LADSPA_PortRangeHint *port_range_hints;

#ifdef ENABLE_NLS
#define D_(s) dgettext(PACKAGE, s)
	setlocale(LC_ALL, "");
	bindtextdomain(PACKAGE, PACKAGE_LOCALE_DIR);
#else
#define D_(s) (s)
#endif


	bwxover_iirDescriptor =
	 (LADSPA_Descriptor *)malloc(sizeof(LADSPA_Descriptor));

	if (bwxover_iirDescriptor) {
		bwxover_iirDescriptor->UniqueID = 1902;
		bwxover_iirDescriptor->Label = "bwxover_iir";
		bwxover_iirDescriptor->Properties =
		 LADSPA_PROPERTY_HARD_RT_CAPABLE;
		bwxover_iirDescriptor->Name =
		 D_("Glame Butterworth X-over Filter");
		bwxover_iirDescriptor->Maker =
		 "Alexander Ehlert <*****@*****.**>";
		bwxover_iirDescriptor->Copyright =
		 "GPL";
		bwxover_iirDescriptor->PortCount = 5;

		port_descriptors = (LADSPA_PortDescriptor *)calloc(5,
		 sizeof(LADSPA_PortDescriptor));
		bwxover_iirDescriptor->PortDescriptors =
		 (const LADSPA_PortDescriptor *)port_descriptors;

		port_range_hints = (LADSPA_PortRangeHint *)calloc(5,
		 sizeof(LADSPA_PortRangeHint));
		bwxover_iirDescriptor->PortRangeHints =
		 (const LADSPA_PortRangeHint *)port_range_hints;

		port_names = (char **)calloc(5, sizeof(char*));
		bwxover_iirDescriptor->PortNames =
		 (const char **)port_names;

		/* Parameters for Cutoff Frequency (Hz) */
		port_descriptors[BWXOVER_IIR_CUTOFF] =
		 LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
		port_names[BWXOVER_IIR_CUTOFF] =
		 D_("Cutoff Frequency (Hz)");
		port_range_hints[BWXOVER_IIR_CUTOFF].HintDescriptor =
		 LADSPA_HINT_BOUNDED_BELOW | LADSPA_HINT_BOUNDED_ABOVE | LADSPA_HINT_DEFAULT_LOW | LADSPA_HINT_SAMPLE_RATE | LADSPA_HINT_LOGARITHMIC;
		port_range_hints[BWXOVER_IIR_CUTOFF].LowerBound = 0.0001;
		port_range_hints[BWXOVER_IIR_CUTOFF].UpperBound = 0.45;

		/* Parameters for Resonance */
		port_descriptors[BWXOVER_IIR_RESONANCE] =
		 LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
		port_names[BWXOVER_IIR_RESONANCE] =
		 D_("Resonance");
		port_range_hints[BWXOVER_IIR_RESONANCE].HintDescriptor =
		 LADSPA_HINT_BOUNDED_BELOW | LADSPA_HINT_BOUNDED_ABOVE | LADSPA_HINT_DEFAULT_MIDDLE;
		port_range_hints[BWXOVER_IIR_RESONANCE].LowerBound = 0.1;
		port_range_hints[BWXOVER_IIR_RESONANCE].UpperBound = 1.41;

		/* Parameters for Input */
		port_descriptors[BWXOVER_IIR_INPUT] =
		 LADSPA_PORT_INPUT | LADSPA_PORT_AUDIO;
		port_names[BWXOVER_IIR_INPUT] =
		 D_("Input");
		port_range_hints[BWXOVER_IIR_INPUT].HintDescriptor = 0;

		/* Parameters for LP-Output */
		port_descriptors[BWXOVER_IIR_LPOUTPUT] =
		 LADSPA_PORT_OUTPUT | LADSPA_PORT_AUDIO;
		port_names[BWXOVER_IIR_LPOUTPUT] =
		 D_("LP-Output");
		port_range_hints[BWXOVER_IIR_LPOUTPUT].HintDescriptor = 0;

		/* Parameters for HP-Output */
		port_descriptors[BWXOVER_IIR_HPOUTPUT] =
		 LADSPA_PORT_OUTPUT | LADSPA_PORT_AUDIO;
		port_names[BWXOVER_IIR_HPOUTPUT] =
		 D_("HP-Output");
		port_range_hints[BWXOVER_IIR_HPOUTPUT].HintDescriptor = 0;

		bwxover_iirDescriptor->activate = activateBwxover_iir;
		bwxover_iirDescriptor->cleanup = cleanupBwxover_iir;
		bwxover_iirDescriptor->connect_port = connectPortBwxover_iir;
		bwxover_iirDescriptor->deactivate = NULL;
		bwxover_iirDescriptor->instantiate = instantiateBwxover_iir;
		bwxover_iirDescriptor->run = runBwxover_iir;
		bwxover_iirDescriptor->run_adding = runAddingBwxover_iir;
		bwxover_iirDescriptor->set_run_adding_gain = setRunAddingGainBwxover_iir;
	}

	buttlow_iirDescriptor =
	 (LADSPA_Descriptor *)malloc(sizeof(LADSPA_Descriptor));

	if (buttlow_iirDescriptor) {
		buttlow_iirDescriptor->UniqueID = 1903;
		buttlow_iirDescriptor->Label = "buttlow_iir";
		buttlow_iirDescriptor->Properties =
		 LADSPA_PROPERTY_HARD_RT_CAPABLE;
		buttlow_iirDescriptor->Name =
		 D_("GLAME Butterworth Lowpass");
		buttlow_iirDescriptor->Maker =
		 "Alexander Ehlert <*****@*****.**>";
		buttlow_iirDescriptor->Copyright =
		 "GPL";
		buttlow_iirDescriptor->PortCount = 4;

		port_descriptors = (LADSPA_PortDescriptor *)calloc(4,
		 sizeof(LADSPA_PortDescriptor));
		buttlow_iirDescriptor->PortDescriptors =
		 (const LADSPA_PortDescriptor *)port_descriptors;

		port_range_hints = (LADSPA_PortRangeHint *)calloc(4,
		 sizeof(LADSPA_PortRangeHint));
		buttlow_iirDescriptor->PortRangeHints =
		 (const LADSPA_PortRangeHint *)port_range_hints;

		port_names = (char **)calloc(4, sizeof(char*));
		buttlow_iirDescriptor->PortNames =
		 (const char **)port_names;

		/* Parameters for Cutoff Frequency (Hz) */
		port_descriptors[BUTTLOW_IIR_CUTOFF] =
		 LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
		port_names[BUTTLOW_IIR_CUTOFF] =
		 D_("Cutoff Frequency (Hz)");
		port_range_hints[BUTTLOW_IIR_CUTOFF].HintDescriptor =
		 LADSPA_HINT_BOUNDED_BELOW | LADSPA_HINT_BOUNDED_ABOVE | LADSPA_HINT_DEFAULT_LOW | LADSPA_HINT_SAMPLE_RATE | LADSPA_HINT_LOGARITHMIC;
		port_range_hints[BUTTLOW_IIR_CUTOFF].LowerBound = 0.0001;
		port_range_hints[BUTTLOW_IIR_CUTOFF].UpperBound = 0.45;

		/* Parameters for Resonance */
		port_descriptors[BUTTLOW_IIR_RESONANCE] =
		 LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
		port_names[BUTTLOW_IIR_RESONANCE] =
		 D_("Resonance");
		port_range_hints[BUTTLOW_IIR_RESONANCE].HintDescriptor =
		 LADSPA_HINT_BOUNDED_BELOW | LADSPA_HINT_BOUNDED_ABOVE | LADSPA_HINT_DEFAULT_MIDDLE;
		port_range_hints[BUTTLOW_IIR_RESONANCE].LowerBound = 0.1;
		port_range_hints[BUTTLOW_IIR_RESONANCE].UpperBound = 1.41;

		/* Parameters for Input */
		port_descriptors[BUTTLOW_IIR_INPUT] =
		 LADSPA_PORT_INPUT | LADSPA_PORT_AUDIO;
		port_names[BUTTLOW_IIR_INPUT] =
		 D_("Input");
		port_range_hints[BUTTLOW_IIR_INPUT].HintDescriptor = 0;

		/* Parameters for Output */
		port_descriptors[BUTTLOW_IIR_OUTPUT] =
		 LADSPA_PORT_OUTPUT | LADSPA_PORT_AUDIO;
		port_names[BUTTLOW_IIR_OUTPUT] =
		 D_("Output");
		port_range_hints[BUTTLOW_IIR_OUTPUT].HintDescriptor = 0;

		buttlow_iirDescriptor->activate = activateButtlow_iir;
		buttlow_iirDescriptor->cleanup = cleanupButtlow_iir;
		buttlow_iirDescriptor->connect_port = connectPortButtlow_iir;
		buttlow_iirDescriptor->deactivate = NULL;
		buttlow_iirDescriptor->instantiate = instantiateButtlow_iir;
		buttlow_iirDescriptor->run = runButtlow_iir;
		buttlow_iirDescriptor->run_adding = runAddingButtlow_iir;
		buttlow_iirDescriptor->set_run_adding_gain = setRunAddingGainButtlow_iir;
	}

	butthigh_iirDescriptor =
	 (LADSPA_Descriptor *)malloc(sizeof(LADSPA_Descriptor));

	if (butthigh_iirDescriptor) {
		butthigh_iirDescriptor->UniqueID = 1904;
		butthigh_iirDescriptor->Label = "butthigh_iir";
		butthigh_iirDescriptor->Properties =
		 LADSPA_PROPERTY_HARD_RT_CAPABLE;
		butthigh_iirDescriptor->Name =
		 D_("GLAME Butterworth Highpass");
		butthigh_iirDescriptor->Maker =
		 "Alexander Ehlert <*****@*****.**>";
		butthigh_iirDescriptor->Copyright =
		 "GPL";
		butthigh_iirDescriptor->PortCount = 4;

		port_descriptors = (LADSPA_PortDescriptor *)calloc(4,
		 sizeof(LADSPA_PortDescriptor));
		butthigh_iirDescriptor->PortDescriptors =
		 (const LADSPA_PortDescriptor *)port_descriptors;

		port_range_hints = (LADSPA_PortRangeHint *)calloc(4,
		 sizeof(LADSPA_PortRangeHint));
		butthigh_iirDescriptor->PortRangeHints =
		 (const LADSPA_PortRangeHint *)port_range_hints;

		port_names = (char **)calloc(4, sizeof(char*));
		butthigh_iirDescriptor->PortNames =
		 (const char **)port_names;

		/* Parameters for Cutoff Frequency (Hz) */
		port_descriptors[BUTTHIGH_IIR_CUTOFF] =
		 LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
		port_names[BUTTHIGH_IIR_CUTOFF] =
		 D_("Cutoff Frequency (Hz)");
		port_range_hints[BUTTHIGH_IIR_CUTOFF].HintDescriptor =
		 LADSPA_HINT_BOUNDED_BELOW | LADSPA_HINT_BOUNDED_ABOVE | LADSPA_HINT_DEFAULT_LOW | LADSPA_HINT_SAMPLE_RATE | LADSPA_HINT_LOGARITHMIC;
		port_range_hints[BUTTHIGH_IIR_CUTOFF].LowerBound = 0.0001;
		port_range_hints[BUTTHIGH_IIR_CUTOFF].UpperBound = 0.45;

		/* Parameters for Resonance */
		port_descriptors[BUTTHIGH_IIR_RESONANCE] =
		 LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
		port_names[BUTTHIGH_IIR_RESONANCE] =
		 D_("Resonance");
		port_range_hints[BUTTHIGH_IIR_RESONANCE].HintDescriptor =
		 LADSPA_HINT_BOUNDED_BELOW | LADSPA_HINT_BOUNDED_ABOVE | LADSPA_HINT_DEFAULT_MIDDLE;
		port_range_hints[BUTTHIGH_IIR_RESONANCE].LowerBound = 0.1;
		port_range_hints[BUTTHIGH_IIR_RESONANCE].UpperBound = 1.41;

		/* Parameters for Input */
		port_descriptors[BUTTHIGH_IIR_INPUT] =
		 LADSPA_PORT_INPUT | LADSPA_PORT_AUDIO;
		port_names[BUTTHIGH_IIR_INPUT] =
		 D_("Input");
		port_range_hints[BUTTHIGH_IIR_INPUT].HintDescriptor = 0;

		/* Parameters for Output */
		port_descriptors[BUTTHIGH_IIR_OUTPUT] =
		 LADSPA_PORT_OUTPUT | LADSPA_PORT_AUDIO;
		port_names[BUTTHIGH_IIR_OUTPUT] =
		 D_("Output");
		port_range_hints[BUTTHIGH_IIR_OUTPUT].HintDescriptor = 0;

		butthigh_iirDescriptor->activate = activateButthigh_iir;
		butthigh_iirDescriptor->cleanup = cleanupButthigh_iir;
		butthigh_iirDescriptor->connect_port = connectPortButthigh_iir;
		butthigh_iirDescriptor->deactivate = NULL;
		butthigh_iirDescriptor->instantiate = instantiateButthigh_iir;
		butthigh_iirDescriptor->run = runButthigh_iir;
		butthigh_iirDescriptor->run_adding = runAddingButthigh_iir;
		butthigh_iirDescriptor->set_run_adding_gain = setRunAddingGainButthigh_iir;
	}
}
Пример #8
0
static int hmn_load(struct module_data *m, HIO_HANDLE * f, const int start)
{
	struct xmp_module *mod = &m->mod;
	int i, j;
	struct xmp_event *event;
	struct mod_header mh;
	struct mupp mupp[31];
	uint8 mod_event[4];
	int mupp_index, num_mupp;

	LOAD_INIT();

	/*
	 *    clr.b   $1c(a6) ;prog on/off
	 *    CMP.L   #'Mupp',-$16(a3,d4.l)
	 *    bne.s   noprgo
	 *    move.l  a0,-(a7)
	 *    move.b  #1,$1c(a6)      ;prog on
	 *    move.l  l697,a0
	 *    lea     $43c(a0),a0
	 *    moveq   #0,d2
	 *    move.b  -$16+$4(a3,d4.l),d2     ;pattno
	 *    mulu    #$400,d2
	 *    lea     (a0,d2.l),a0
	 *    move.l  a0,4(a6)        ;proginstr data-start
	 *    moveq   #0,d2
	 *    MOVE.B  $3C0(A0),$12(A6)
	 *    AND.B   #$7F,$12(A6)
	 *    move.b  $380(a0),d2
	 *    mulu    #$20,d2
	 *    lea     (a0,d2.w),a0
	 *    move.l  a0,$a(a6)       ;loopstartmempoi = startmempoi
	 *    move.B  $3(a3,d4.l),$13(a6)     ;volume
	 *    move.b  -$16+$5(a3,d4.l),8(a6)  ;dataloopstart
	 *    move.b  -$16+$6(a3,d4.l),9(a6)  ;dataloopend
	 *    move.w  #$10,$e(a6)     ;looplen
	 *    move.l  (a7)+,a0
	 *    MOVE.W  $12(A6),(A2)
	 *    AND.W   #$FF,(A2)
	 *    BRA.S   L505_LQ
	 */

	/*
	 * Wavetable structure is 22 * 32 byte waveforms and 32 byte
	 * wave control data with looping.
	 */
	memset(mupp, 0, 31 * sizeof (struct mupp));

	hio_read(&mh.name, 20, 1, f);
	num_mupp = 0;

	for (i = 0; i < 31; i++) {
		hio_read(&mh.ins[i].name, 22, 1, f);	/* Instrument name */
		if (memcmp(mh.ins[i].name, "Mupp", 4) == 0) {
			mupp[i].prgon = 1;
			mupp[i].pattno = mh.ins[i].name[4];
			mupp[i].dataloopstart = mh.ins[i].name[5];
			mupp[i].dataloopend = mh.ins[i].name[6];
			num_mupp++;
		}

		mh.ins[i].size = hio_read16b(f);
		mh.ins[i].finetune = hio_read8(f);
		mh.ins[i].volume = hio_read8(f);
		mh.ins[i].loop_start = hio_read16b(f);
		mh.ins[i].loop_size = hio_read16b(f);
	}
	mh.len = hio_read8(f);
	mh.restart = hio_read8(f);
	hio_read(&mh.order, 128, 1, f);
	hio_read(&mh.magic, 4, 1, f);

	mod->chn = 4;
	mod->ins = 31;
	mod->smp = mod->ins + 28 * num_mupp;
	mod->len = mh.len;
	mod->rst = mh.restart;
	memcpy(mod->xxo, mh.order, 128);

	for (i = 0; i < 128; i++) {
		if (mod->xxo[i] > mod->pat)
			mod->pat = mod->xxo[i];
	}

	mod->pat++;
	mod->trk = mod->chn * mod->pat;

	if (hmn_new_module_extras(m) != 0)
		return -1;

	strncpy(mod->name, (char *)mh.name, 20);
	set_type(m, "%s (%4.4s)", "His Master's Noise", mh.magic);
	MODULE_INFO();

	if (instrument_init(mod) < 0)
		return -1;

	for (i = 0; i < mod->ins; i++) {
		if (mupp[i].prgon) {
			mod->xxi[i].nsm = 28;
			snprintf(mod->xxi[i].name, 32,
				"Mupp %02x %02x %02x", mupp[i].pattno,
				mupp[i].dataloopstart, mupp[i].dataloopend);
			if (hmn_new_instrument_extras(&mod->xxi[i]) != 0)
				return -1;
		} else {
			mod->xxi[i].nsm = 1;
			instrument_name(mod, i, mh.ins[i].name, 22);

			mod->xxs[i].len = 2 * mh.ins[i].size;
			mod->xxs[i].lps = 2 * mh.ins[i].loop_start;
			mod->xxs[i].lpe = mod->xxs[i].lps +
						2 * mh.ins[i].loop_size;
			mod->xxs[i].flg = mh.ins[i].loop_size > 1 ?
						XMP_SAMPLE_LOOP : 0;
		}

		if (subinstrument_alloc(mod, i, mod->xxi[i].nsm) < 0)
			return -1;

		for (j = 0; j < mod->xxi[i].nsm; j++) {
			mod->xxi[i].sub[j].fin =
					-(int8)(mh.ins[i].finetune << 3);
			mod->xxi[i].sub[j].vol = mh.ins[i].volume;
			mod->xxi[i].sub[j].pan = 0x80;
			mod->xxi[i].sub[j].sid = i;
		}
	}

	if (pattern_init(mod) < 0)
		return -1;

	/* Load and convert patterns */
	D_(D_INFO "Stored patterns: %d", mod->pat);

	for (i = 0; i < mod->pat; i++) {
		if (pattern_tracks_alloc(mod, i, 64) < 0)
			return -1;

		for (j = 0; j < (64 * 4); j++) {
			event = &EVENT(i, j % 4, j / 4);
			hio_read(mod_event, 1, 4, f);
			decode_protracker_event(event, mod_event);

			switch (event->fxt) {
			case 0x07:
				event->fxt = FX_MEGAARP;
				break;
			case 0x08:
			case 0x09:
			case 0x0e:
				event->fxt = event->fxp = 0;
				break;
			}
		}
	}

	m->period_type = PERIOD_MODRNG;

	/* Load samples */

	D_(D_INFO "Stored samples: %d", mod->smp);

	for (i = 0; i < 31; i++) {
		if (load_sample(m, f, SAMPLE_FLAG_FULLREP,
						&mod->xxs[i], NULL) < 0) {
			return -1;
		}
	}


	/* Load Mupp samples */

	mupp_index = 0;
	for (i = 0; i < 31; i ++) {
		struct hmn_instrument_extras *extra =
			(struct hmn_instrument_extras *)mod->xxi[i].extra;

		if (!mupp[i].prgon)
			continue;

		hio_seek(f, start + 1084 + 1024 * mupp[i].pattno, SEEK_SET);
		for (j = 0; j < 28; j++) {
			int k = 31 + 28 * mupp_index + j;
			mod->xxi[i].sub[j].sid = k;
			mod->xxs[k].len = 32;
			mod->xxs[k].lps = 0;
			mod->xxs[k].lpe = 32;
			mod->xxs[k].flg = XMP_SAMPLE_LOOP;
			if (load_sample(m, f, 0, &mod->xxs[k], NULL) < 0)
				return -1;
		}

		extra->dataloopstart = mupp[i].dataloopstart;
		extra->dataloopend = mupp[i].dataloopend;

		hio_read(extra->data, 1, 64, f);
		hio_read(extra->progvolume, 1, 64, f);

		mupp_index++;
	}

	return 0;
}
Пример #9
0
struct MessageListViewData *
message_list_view_show(struct Window *win, GHashTable * options)
{
	g_debug("message_list_view_show()");
	struct MessageListViewData *data =
		g_slice_alloc0(sizeof(struct MessageListViewData));
	data->win = win;

	window_layout_set(win, MESSAGE_FILE, "list");
	window_text_set(win, "title", D_("Inbox"));

	data->bt1 = elm_button_add(window_evas_object_get(win));
	elm_button_label_set(data->bt1, D_("New"));
	evas_object_smart_callback_add(data->bt1, "clicked",
				       message_list_view_new_clicked, data);
	window_swallow(win, "button_new", data->bt1);
	evas_object_show(data->bt1);


	// Options button with hover
	data->hv = elm_hover_add(window_evas_object_get(win));

	data->bt2 = elm_button_add(window_evas_object_get(win));
	elm_button_label_set(data->bt2, D_("Options"));
	evas_object_smart_callback_add(data->bt2, "clicked", my_hover_bt_1,
				       data->hv);
	window_swallow(win, "button_options", data->bt2);
	evas_object_show(data->bt2);

	elm_hover_parent_set(data->hv, window_evas_object_get(win));
	elm_hover_target_set(data->hv, data->bt2);

	data->bx = elm_box_add(window_evas_object_get(win));
	elm_box_horizontal_set(data->bx, 0);
	elm_box_homogenous_set(data->bx, 1);
	evas_object_show(data->bx);

	data->button_answer = elm_button_add(window_evas_object_get(win));
	elm_button_label_set(data->button_answer, D_("Answer"));
	evas_object_size_hint_min_set(data->button_answer, 130, 80);
	evas_object_smart_callback_add(data->button_answer, "clicked",
				       message_list_view_answer_clicked, data);
	evas_object_show(data->button_answer);
	elm_box_pack_end(data->bx, data->button_answer);

	data->button_delete = elm_button_add(window_evas_object_get(win));
	elm_button_label_set(data->button_delete, D_("Delete"));
	evas_object_size_hint_min_set(data->button_delete, 130, 80);
	evas_object_smart_callback_add(data->button_delete, "clicked",
				       message_list_view_delete_clicked, data);
	evas_object_show(data->button_delete);
	elm_box_pack_end(data->bx, data->button_delete);

	elm_hover_content_set(data->hv, "top", data->bx);


	data->bt3 = elm_button_add(window_evas_object_get(win));
	elm_button_label_set(data->bt3, D_("Show"));
	evas_object_smart_callback_add(data->bt3, "clicked",
				       message_list_view_show_clicked, data);
	window_swallow(win, "button_show", data->bt3);
	evas_object_show(data->bt3);


	g_debug("tree init");

	data->tree = etk_tree_new();
	etk_tree_rows_height_set(ETK_TREE(data->tree), 80);
	etk_tree_mode_set(ETK_TREE(data->tree), ETK_TREE_MODE_LIST);
	etk_tree_headers_visible_set(ETK_TREE(data->tree), ETK_FALSE);
	etk_tree_multiple_select_set(ETK_TREE(data->tree), ETK_FALSE);

	data->col1 = etk_tree_col_new(ETK_TREE(data->tree), "Title", 300, 0.0);
	etk_tree_col_model_add(data->col1,
			       etk_tree_model_edje_new(MESSAGE_FILE,
						       "message_row"));
	etk_tree_build(ETK_TREE(data->tree));

	Etk_Scrolled_View *scrolled_view =
		etk_tree_scrolled_view_get(ETK_TREE(data->tree));
	etk_scrolled_view_dragable_set(ETK_SCROLLED_VIEW(scrolled_view),
				       ETK_TRUE);
	etk_scrolled_view_drag_bouncy_set(ETK_SCROLLED_VIEW(scrolled_view),
					  ETK_FALSE);
	etk_scrolled_view_policy_set(ETK_SCROLLED_VIEW(scrolled_view),
				     ETK_POLICY_HIDE, ETK_POLICY_HIDE);

	data->container =
		etk_embed_new(evas_object_evas_get
			      (window_evas_object_get(win)));
	etk_container_add(ETK_CONTAINER(data->container), data->tree);
	etk_widget_show_all(data->container);

	window_swallow(win, "list",
		       etk_embed_object_get(ETK_EMBED(data->container)));


	ogsmd_sim_retrieve_messagebook("all", retrieve_messagebook_callback,
				       data);
	window_show(win);
	return data;
}
Пример #10
0
void utils_slide_delete(List_Item *item)
{
    int i = 0;
    Eina_List *l;
    List_Item *_item;

    EINA_LIST_FOREACH(l_slides, l, _item)
    {
        if(item == _item)
            break;
        else
            i++;
    }


    Evas_Object *lbl, *tb, *bt, *icon;
    char buf[PATH_MAX];
    snprintf(buf, sizeof(buf), "%s/theme.edj", PACKAGE_DATA_DIR);

    _inwin_delete_slide = elm_win_inwin_add(win);
    evas_object_show(_inwin_delete_slide);
    elm_object_style_set(_inwin_delete_slide, "minimal");

    tb = elm_table_add(win);
    elm_win_inwin_content_set(_inwin_delete_slide, tb);

    //icon
    icon = edje_object_add(evas_object_evas_get(win));
    edje_object_file_set(icon, buf, "list/slides/icon");

    evas_object_size_hint_min_set(icon,1024*0.20,768*0.20);
    evas_object_size_hint_max_set(icon,1024*0.20,768*0.20);

    if(item->thumb)
    {
        int w = item->thumb->w;
        int h = item->thumb->h;
        int *image = calloc(w*h, sizeof(int));
        memcpy(image, item->thumb->thumb, sizeof(int)*w*h);

        const Evas_Object *o_image = edje_object_part_object_get(icon, "object.icon");
        evas_object_image_filled_set((Evas_Object*)o_image,1);
        evas_object_color_set((Evas_Object*)o_image,255,255,255,255);
        evas_object_image_size_set((Evas_Object*)o_image, w, h);
        evas_object_image_data_set((Evas_Object*)o_image, image);

        edje_object_signal_emit(icon, "icon,show", "eyelight");
    }
    evas_object_show(icon);
    elm_table_pack(tb, icon, 0, 0, 2, 1);
    //

    bt= elm_button_add(win);
    elm_object_text_set(bt, "Invisible button to add a vertical space");
    elm_table_pack(tb, bt, 0, 1, 1, 1);

    lbl = elm_label_add(win);
    elm_object_text_set(lbl, D_("Are you sure you want to delete this slide ?"));
    elm_table_pack(tb, lbl, 0, 2, 2, 1);
    evas_object_show(lbl);

    bt= elm_button_add(win);
    elm_object_text_set(bt, "Invisible button to add a vertical space");
    elm_table_pack(tb, bt, 0, 3, 1, 1);

    bt= elm_button_add(win);
    elm_object_text_set(bt, D_("Yes, Delete the slide"));
    evas_object_smart_callback_add(bt, "clicked", _utils_slide_delete_cb, item);
    evas_object_color_set(bt, 255, 0, 0, 255);
    elm_table_pack(tb, bt, 0, 4, 1, 1);
    evas_object_show(bt);

    bt= elm_button_add(win);
    elm_object_text_set(bt, D_("No, do not delete the slide"));
    evas_object_smart_callback_add(bt, "clicked", _utils_slide_delete_cancel_cb, item);
    elm_table_pack(tb, bt, 1, 4, 1, 1);
    evas_object_show(bt);
}
void __attribute__((constructor)) swh_init() {
	char **port_names;
	LADSPA_PortDescriptor *port_descriptors;
	LADSPA_PortRangeHint *port_range_hints;

#ifdef ENABLE_NLS
#define D_(s) dgettext(PACKAGE, s)
	bindtextdomain(PACKAGE, PACKAGE_LOCALE_DIR);
#else
#define D_(s) (s)
#endif


	pointerCastDistortionDescriptor =
	 (LADSPA_Descriptor *)malloc(sizeof(LADSPA_Descriptor));

	if (pointerCastDistortionDescriptor) {
		pointerCastDistortionDescriptor->UniqueID = 1910;
		pointerCastDistortionDescriptor->Label = "pointerCastDistortion";
		pointerCastDistortionDescriptor->Properties =
		 LADSPA_PROPERTY_HARD_RT_CAPABLE;
		pointerCastDistortionDescriptor->Name =
		 D_("Pointer cast distortion");
		pointerCastDistortionDescriptor->Maker =
		 "Steve Harris <*****@*****.**>";
		pointerCastDistortionDescriptor->Copyright =
		 "GPL";
		pointerCastDistortionDescriptor->PortCount = 4;

		port_descriptors = (LADSPA_PortDescriptor *)calloc(4,
		 sizeof(LADSPA_PortDescriptor));
		pointerCastDistortionDescriptor->PortDescriptors =
		 (const LADSPA_PortDescriptor *)port_descriptors;

		port_range_hints = (LADSPA_PortRangeHint *)calloc(4,
		 sizeof(LADSPA_PortRangeHint));
		pointerCastDistortionDescriptor->PortRangeHints =
		 (const LADSPA_PortRangeHint *)port_range_hints;

		port_names = (char **)calloc(4, sizeof(char*));
		pointerCastDistortionDescriptor->PortNames =
		 (const char **)port_names;

		/* Parameters for Effect cutoff freq (Hz) */
		port_descriptors[POINTERCASTDISTORTION_CUTOFF] =
		 LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
		port_names[POINTERCASTDISTORTION_CUTOFF] =
		 D_("Effect cutoff freq (Hz)");
		port_range_hints[POINTERCASTDISTORTION_CUTOFF].HintDescriptor =
		 LADSPA_HINT_BOUNDED_BELOW | LADSPA_HINT_BOUNDED_ABOVE | LADSPA_HINT_LOGARITHMIC | LADSPA_HINT_SAMPLE_RATE | LADSPA_HINT_DEFAULT_LOW;
		port_range_hints[POINTERCASTDISTORTION_CUTOFF].LowerBound = 0.0001;
		port_range_hints[POINTERCASTDISTORTION_CUTOFF].UpperBound = 0.3;

		/* Parameters for Dry/wet mix */
		port_descriptors[POINTERCASTDISTORTION_WET] =
		 LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
		port_names[POINTERCASTDISTORTION_WET] =
		 D_("Dry/wet mix");
		port_range_hints[POINTERCASTDISTORTION_WET].HintDescriptor =
		 LADSPA_HINT_BOUNDED_BELOW | LADSPA_HINT_BOUNDED_ABOVE | LADSPA_HINT_DEFAULT_0;
		port_range_hints[POINTERCASTDISTORTION_WET].LowerBound = 0;
		port_range_hints[POINTERCASTDISTORTION_WET].UpperBound = 1;

		/* Parameters for Input */
		port_descriptors[POINTERCASTDISTORTION_INPUT] =
		 LADSPA_PORT_INPUT | LADSPA_PORT_AUDIO;
		port_names[POINTERCASTDISTORTION_INPUT] =
		 D_("Input");
		port_range_hints[POINTERCASTDISTORTION_INPUT].HintDescriptor = 0;

		/* Parameters for Output */
		port_descriptors[POINTERCASTDISTORTION_OUTPUT] =
		 LADSPA_PORT_OUTPUT | LADSPA_PORT_AUDIO;
		port_names[POINTERCASTDISTORTION_OUTPUT] =
		 D_("Output");
		port_range_hints[POINTERCASTDISTORTION_OUTPUT].HintDescriptor = 0;

		pointerCastDistortionDescriptor->activate = activatePointerCastDistortion;
		pointerCastDistortionDescriptor->cleanup = cleanupPointerCastDistortion;
		pointerCastDistortionDescriptor->connect_port = connectPortPointerCastDistortion;
		pointerCastDistortionDescriptor->deactivate = NULL;
		pointerCastDistortionDescriptor->instantiate = instantiatePointerCastDistortion;
		pointerCastDistortionDescriptor->run = runPointerCastDistortion;
		pointerCastDistortionDescriptor->run_adding = runAddingPointerCastDistortion;
		pointerCastDistortionDescriptor->set_run_adding_gain = setRunAddingGainPointerCastDistortion;
	}
}
Пример #12
0
void utils_edit_area_layout_stack_set (void *data, Evas_Object *obj, void *event_info)
{
    rightpanel_area_layout_set(D_("Stack"));
    eyelight_edit_area_layout_set(_current_obj, "stack");
}
Пример #13
0
void utils_edit_area_layout_horizontal_flow_set (void *data, Evas_Object *obj, void *event_info)
{
    rightpanel_area_layout_set(D_("Horizontal flow"));
    eyelight_edit_area_layout_set(_current_obj, "horizontal_flow");
}
Пример #14
0
void utils_edit_area_layout_vertical_homogeneous_set (void *data, Evas_Object *obj, void *event_info)
{
    rightpanel_area_layout_set(D_("Vertical homogeneous"));
    eyelight_edit_area_layout_set(_current_obj, "vertical_homogeneous");
}
Пример #15
0
static void __attribute__((constructor)) swh_init() {
	char **port_names;
	LADSPA_PortDescriptor *port_descriptors;
	LADSPA_PortRangeHint *port_range_hints;

#ifdef ENABLE_NLS
#define D_(s) dgettext(PACKAGE, s)
	bindtextdomain(PACKAGE, PACKAGE_LOCALE_DIR);
#else
#define D_(s) (s)
#endif


	rateShifterDescriptor =
	 (LADSPA_Descriptor *)malloc(sizeof(LADSPA_Descriptor));

	if (rateShifterDescriptor) {
		rateShifterDescriptor->UniqueID = 1417;
		rateShifterDescriptor->Label = "rateShifter";
		rateShifterDescriptor->Properties =
		 LADSPA_PROPERTY_HARD_RT_CAPABLE;
		rateShifterDescriptor->Name =
		 D_("Rate shifter");
		rateShifterDescriptor->Maker =
		 "Steve Harris <*****@*****.**>";
		rateShifterDescriptor->Copyright =
		 "GPL";
		rateShifterDescriptor->PortCount = 3;

		port_descriptors = (LADSPA_PortDescriptor *)calloc(3,
		 sizeof(LADSPA_PortDescriptor));
		rateShifterDescriptor->PortDescriptors =
		 (const LADSPA_PortDescriptor *)port_descriptors;

		port_range_hints = (LADSPA_PortRangeHint *)calloc(3,
		 sizeof(LADSPA_PortRangeHint));
		rateShifterDescriptor->PortRangeHints =
		 (const LADSPA_PortRangeHint *)port_range_hints;

		port_names = (char **)calloc(3, sizeof(char*));
		rateShifterDescriptor->PortNames =
		 (const char **)port_names;

		/* Parameters for Rate */
		port_descriptors[RATESHIFTER_RATE] =
		 LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
		port_names[RATESHIFTER_RATE] =
		 D_("Rate");
		port_range_hints[RATESHIFTER_RATE].HintDescriptor =
		 LADSPA_HINT_BOUNDED_BELOW | LADSPA_HINT_BOUNDED_ABOVE | LADSPA_HINT_DEFAULT_1;
		port_range_hints[RATESHIFTER_RATE].LowerBound = -4;
		port_range_hints[RATESHIFTER_RATE].UpperBound = 4;

		/* Parameters for Input */
		port_descriptors[RATESHIFTER_INPUT] =
		 LADSPA_PORT_INPUT | LADSPA_PORT_AUDIO;
		port_names[RATESHIFTER_INPUT] =
		 D_("Input");
		port_range_hints[RATESHIFTER_INPUT].HintDescriptor = 0;

		/* Parameters for Output */
		port_descriptors[RATESHIFTER_OUTPUT] =
		 LADSPA_PORT_OUTPUT | LADSPA_PORT_AUDIO;
		port_names[RATESHIFTER_OUTPUT] =
		 D_("Output");
		port_range_hints[RATESHIFTER_OUTPUT].HintDescriptor = 0;

		rateShifterDescriptor->activate = activateRateShifter;
		rateShifterDescriptor->cleanup = cleanupRateShifter;
		rateShifterDescriptor->connect_port = connectPortRateShifter;
		rateShifterDescriptor->deactivate = NULL;
		rateShifterDescriptor->instantiate = instantiateRateShifter;
		rateShifterDescriptor->run = runRateShifter;
		rateShifterDescriptor->run_adding = runAddingRateShifter;
		rateShifterDescriptor->set_run_adding_gain = setRunAddingGainRateShifter;
	}
}
Пример #16
0
static int stc_load(struct module_data *m, HIO_HANDLE * f, const int start)
{
	struct xmp_module *mod = &m->mod;
	struct xmp_event *event /*, *noise*/;
	int i, j;
	uint8 buf[100];
	int pos_ptr, orn_ptr, pat_ptr;
	struct stc_ord stc_ord[256];
	struct stc_pat stc_pat[MAX_PAT];
	int num, flag, orn;
	int *decoded;
	struct spectrum_extra *se;

	LOAD_INIT();

	mod->spd = hio_read8(f);		/* Speed */
	pos_ptr = hio_read16l(f);		/* Positions pointer */
	orn_ptr = hio_read16l(f);		/* Ornaments pointer */
	pat_ptr = hio_read16l(f);		/* Patterns pointer */

	hio_read(buf, 18, 1, f);		/* Title */
	copy_adjust(mod->name, (uint8 *)buf, 18);
	set_type(m, "ZX Spectrum Sound Tracker");

	hio_read16l(f);			/* Size */

	/* Read orders */

	hio_seek(f, pos_ptr, SEEK_SET);
	mod->len = hio_read8(f) + 1;

	for (num = i = 0; i < mod->len; i++) {
		stc_ord[i].pattern = hio_read8(f);
		stc_ord[i].height = hio_read8s(f);
		//printf("%d %d -- ", stc_ord[i].pattern, stc_ord[i].height);

		for (flag = j = 0; j < i; j++) {
			if (stc_ord[i].pattern == stc_ord[j].pattern &&
				stc_ord[i].height == stc_ord[j].height)
			{
				mod->xxo[i] = mod->xxo[j];
				flag = 1;
				break;
			}
		}
		if (!flag) {
			mod->xxo[i] = num++;
		}
		//printf("%d\n", mod->xxo[i]);
	}

	mod->chn = 3;
	mod->pat = num;
	mod->trk = mod->pat * mod->chn;
	mod->ins = 15;
	mod->smp = mod->ins;
	orn = (pat_ptr - orn_ptr) / 33;

	MODULE_INFO();

	/* Read patterns */

	if (pattern_init(mod) < 0)
		return -1;

	hio_seek(f, pat_ptr, SEEK_SET);
	decoded = calloc(mod->pat, sizeof(int));
	D_(D_INFO "Stored patterns: %d ", mod->pat);

	for (i = 0; i < MAX_PAT; i++) {
		if (hio_read8(f) == 0xff)
			break;
		stc_pat[i].ch[0] = hio_read16l(f);
		stc_pat[i].ch[1] = hio_read16l(f);
		stc_pat[i].ch[2] = hio_read16l(f);
	}

	for (i = 0; i < mod->len; i++) {		/* pattern */
		int src = stc_ord[i].pattern - 1;
		int dest = mod->xxo[i];
		int trans = stc_ord[i].height;

		if (decoded[dest])
			continue;

		//printf("%d/%d) Read pattern %d -> %d\n", i, mod->len, src, dest);

		if (pattern_tracks_alloc(mod, dest, 64) < 0)
			return -1;

		for (j = 0; j < 3; j++) {		/* row */
			int row = 0;
			int x;
			int rowinc = 0;
	
			hio_seek(f, stc_pat[src].ch[j], SEEK_SET);

			do {
				for (;;) {
					x = hio_read8(f);

					if (x == 0xff)
						break;
	
//printf("pat %d, channel %d, row %d, x = %02x\n", dest, j, row, x);
					event = &EVENT(dest, j, row);
				
					if (x <= 0x5f) {
						event->note = x + 18 + trans;
						row += 1 + rowinc;
						break;
					}

					if (x <= 0x6f) {
						event->ins = x - 0x5f - 1;
					} else if (x <= 0x7f) {
						/* ornament*/
						event->fxt = FX_SYNTH_0;
						event->fxp = x - 0x70;
					} else if (x == 0x80) {
						event->note = XMP_KEY_OFF;
						row += 1 + rowinc;
						break;
					} else if (x == 0x81) {
						/* ? */
						row += 1 + rowinc;
					} else if (x == 0x82) {
						/* disable ornament/envelope */
						event->fxt = FX_SYNTH_0;
						event->fxp = 0;
						event->f2t = FX_SYNTH_2;
						event->f2p = 0;
					} else if (x <= 0x8e) {
						/* envelope */
						event->fxt = FX_SYNTH_0 +
							x - 0x80;      /* R13 */
						event->fxp = hio_read8(f); /* R11 */
						event->f2t = FX_SYNTH_1;
						event->f2p = hio_read8(f); /* R12 */
					} else {
						rowinc = x - 0xa1;
					}
				}
			} while (x != 0xff);
		}

		decoded[dest] = 1;
	}

	free(decoded);

	/* Read instruments */

	if (instrument_init(mod) < 0)
		return -1;

	hio_seek(f, 27, SEEK_SET);

	D_(D_INFO "Instruments: %d", mod->ins);
	for (i = 0; i < mod->ins; i++) {
		struct spectrum_sample ss;

		memset(&ss, 0, sizeof (struct spectrum_sample));
		if (subinstrument_alloc(mod, i, 1) < 0)
			return -1;
		mod->xxi[i].nsm = 1;
		mod->xxi[i].sub[0].vol = 0x40;
		mod->xxi[i].sub[0].pan = 0x80;
		mod->xxi[i].sub[0].xpo = -1;
		mod->xxi[i].sub[0].sid = i;

		hio_read(buf, 1, 99, f);

		if (buf[97] == 0) {
			ss.loop = 32;
			ss.length = 33;
		} else {
			ss.loop = buf[97] - 1;
			if (ss.loop > 31)
				ss.loop = 31;
			ss.length = buf[97] + buf[98];
			if (ss.length > 32)
				ss.length = 32;
			if (ss.length == 0)
				ss.length = 1;
			if (ss.loop >= ss.length)
				ss.loop = ss.length - 1;

			if (ss.length < 32) {
				ss.length += 33 - (ss.loop + 1);
				ss.loop = 32;
			}
		}

		/* Read sample ticks */

		for (j = 0; j < 31; j++) {
			struct spectrum_stick *sst = &ss.stick[j];
			uint8 *chdata = &buf[1 + j * 3];
			
			memset(sst, 0, sizeof (struct spectrum_stick));

			if (~chdata[1] & 0x80) {
				sst->flags |= SPECTRUM_FLAG_MIXNOISE;
				sst->noise_env_inc = chdata[1] & 0x1f;

				if (sst->noise_env_inc & 0x10)
					sst->noise_env_inc |= 0xf0;
			}

			if (~chdata[1] & 0x40)
				sst->flags |= SPECTRUM_FLAG_MIXTONE;

			sst->vol = chdata[0] & 0x0f;

			sst->tone_inc = (((int)(chdata[0] & 0xf0)) << 4) |
						chdata[2];

			if (~chdata[1] & 0x20)
				sst->tone_inc = -sst->tone_inc;

			sst->flags |= SPECTRUM_FLAG_ENVELOPE;

			/*if (j != 0) {
				reportv(ctx, 1, "               ");
			}
			reportv(ctx, 1, "%02X %c%c%c %c%03x %x\n", j,
				sst->flags & SPECTRUM_FLAG_MIXTONE ? 'T' : 't',
				sst->flags & SPECTRUM_FLAG_MIXNOISE ? 'N' : 'n',
				sst->flags & SPECTRUM_FLAG_ENVELOPE ? 'E' : 'e',
				sst->tone_inc >= 0 ? '+' : '-',
				sst->tone_inc >= 0 ?
					sst->tone_inc : -sst->tone_inc,
				sst->vol);*/
			
		}

		if (load_sample(m, f, SAMPLE_FLAG_SPECTRUM, &mod->xxs[i],
							(char *)&ss) < 0) {
			return -1;
		}
	}
	
	/* Read ornaments */

	hio_seek(f, orn_ptr, SEEK_SET);
	m->extra = calloc(1, sizeof (struct spectrum_extra));
	se = m->extra;

	D_(D_INFO "Ornaments: %d", orn);
	for (i = 0; i < orn; i++) {
		int index;
		struct spectrum_ornament *so;

		index = hio_read8(f);		

		so = &se->ornament[index];
		so->length = 32;
		so->loop = 31;

		for (j = 0; j < 32; j++) {
			so->val[j] = hio_read8s(f);
		}
	}

	for (i = 0; i < 4; i++) {
		mod->xxc[i].pan = 0x80;
		mod->xxc[i].flg = XMP_CHANNEL_SYNTH;
	}
	
	m->synth = &synth_spectrum;

	return 0;
}
Пример #17
0
void rpmRunFileTriggers(const char * rootDir)
{
    miRE matches_any = mireNew(RPMMIRE_DEFAULT, 0);
    int nft = 0;
    struct filetrigger *list = NULL;
    const char * fn = NULL;
    FD_t fd = NULL;
    FILE * fp = NULL;
    int xx;

    rpmlog(RPMLOG_DEBUG, D_("[filetriggers] starting\n"));

    fn = rpmGenPath(rootDir, files_awaiting_filetriggers, NULL);

    if (!filetriggers_dir())
	goto exit;

    getFiletriggers(rootDir, matches_any, &nft, &list);
    if (nft <= 0)
	goto exit;

    fd = Fopen(fn, "r.fpio");
    if (fd == NULL)
	goto exit;

    fp = fdGetFILE(fd);

    if (fp != NULL) {
	void (*oldhandler)(int) = signal(SIGPIPE, SIG_IGN);
	char tmp[BUFSIZ];
	int i;

	rpmlog(RPMLOG_DEBUG,
		D_("[filetriggers] testing files from list: %s\n"), fn);

	while (fgets(tmp, (int)sizeof(tmp), fp)) {
	    size_t tmplen = strlen(tmp);

	    if (tmplen > 0 && tmp[tmplen-1] == '\n')
		tmp[--tmplen] = '\0';

	    if (!is_regexp_matching(matches_any, tmp))
		continue;

	    rpmlog(RPMLOG_DEBUG,
			D_("[filetriggers] matches-any regexp found %s\n"),
			tmp);

	    for (i = 0; i < nft; i++) {
		ssize_t nw;
		if (!is_regexp_matching(list[i].mire, tmp))
		    /*@innercontinue@*/ continue;

		rpmlog(RPMLOG_DEBUG,
			D_("[filetriggers] file name '%s' matches pattern '%s'\n"),
			tmp, list[i].mire->pattern);

		mayStartFiletrigger(rootDir, &list[i]);
		nw = write(list[i].command_pipe, tmp, tmplen);
	    }
	}

	xx = Fclose(fd);
	fd = NULL;
	fp = NULL;

	for (i = 0; i < nft; i++) {
	    int status;
	    if (list[i].command_pipe) {
		pid_t pid;
		xx = close(list[i].command_pipe);
		rpmlog(RPMLOG_DEBUG,
			D_("[filetriggers] waiting for %s to end\n"),
			list[i].name);
		pid = waitpid(list[i].command_pid, &status, 0);
		list[i].command_pipe = 0;
	    }
	}

	freeFiletriggers(matches_any, nft, list);

	oldhandler = signal(SIGPIPE, oldhandler);
    }

exit:
    if (fn != NULL)
	xx = unlink(fn);
    fn = _free(fn);
}
Пример #18
0
static gboolean _on_click_module_tree_view (GtkTreeView *pTreeView, GdkEventButton* pButton, gpointer data)
{
	//g_print ("%s ()\n", __func__);
	if ((pButton->button == 3 && pButton->type == GDK_BUTTON_RELEASE)  // right-click
	|| (pButton->button == 1 && pButton->type == GDK_2BUTTON_PRESS))  // double-click
	{
		cd_debug ("%s ()", __func__);
		// get the current selected line.
		GtkTreeSelection *pSelection = gtk_tree_view_get_selection (pTreeView);
		GtkTreeModel *pModel;
		GtkTreeIter iter;
		if (! gtk_tree_selection_get_selected (pSelection, &pModel, &iter))
			return FALSE;
		
		gchar *cName = NULL, *cUri = NULL;
		guint id = 0;
		gtk_tree_model_get (pModel, &iter,
			CD_MODEL_NAME, &cName,
			CD_MODEL_URI, &cUri,
			CD_MODEL_ID, &id, -1);
		
		//launch or build the menu.
		gboolean bIsAppli = (strncmp (cUri, "application://", 14) == 0);
		if (pButton->button == 1)  // double-click
		{
			if (bIsAppli)  // an appli -> run it
			{
				gchar *tmp = strrchr (cUri, '.');  // remove the '.desktop'
				if (tmp)
					*tmp = '\0';
				cairo_dock_launch_command (cUri+14);
			}
			else  // a file -> open it
			{
				cairo_dock_fm_launch_uri (cUri);
			}
			g_free (cUri);
		}
		else  // right-click
		{
			GtkWidget *pMenu = gldi_menu_new (NULL);
			g_free (myData.cCurrentUri);
			myData.cCurrentUri = cUri;
			
			if (!bIsAppli)
			{
				GList *pApps = cairo_dock_fm_list_apps_for_file (cUri);
				if (pApps != NULL)
				{
					GtkWidget *pSubMenu = CD_APPLET_ADD_SUB_MENU_WITH_IMAGE (D_("Open with"), pMenu, GLDI_ICON_NAME_OPEN);
					
					cd_folders_free_apps_list (myApplet);
					
					GList *a;
					gchar **pAppInfo;
					gchar *cIconPath;
					for (a = pApps; a != NULL; a = a->next)
					{
						pAppInfo = a->data;
						myData.pAppList = g_list_prepend (myData.pAppList, pAppInfo[1]);
						
						if (pAppInfo[2] != NULL)
							cIconPath = cairo_dock_search_icon_s_path (pAppInfo[2], cairo_dock_search_icon_size (GTK_ICON_SIZE_MENU));
						else
							cIconPath = NULL;
						CD_APPLET_ADD_IN_MENU_WITH_STOCK_AND_DATA (pAppInfo[0], cIconPath, _cd_launch_with, pSubMenu, pAppInfo[1]);
						g_free (cIconPath);
						g_free (pAppInfo[0]);
						g_free (pAppInfo[2]);
						g_free (pAppInfo);
					}
					g_list_free (pApps);
				}
				CD_APPLET_ADD_IN_MENU_WITH_STOCK_AND_DATA (D_("Open parent folder"), GLDI_ICON_NAME_DIRECTORY, _cd_open_parent, pMenu, NULL);
				
				CD_APPLET_ADD_IN_MENU_WITH_STOCK_AND_DATA (D_("Copy the location"), GLDI_ICON_NAME_COPY, _cd_copy_location, pMenu, NULL);
			}
			
			CD_APPLET_ADD_IN_MENU_WITH_STOCK_AND_DATA (D_("Delete this event"), GLDI_ICON_NAME_REMOVE, _cd_delete_event, pMenu, GUINT_TO_POINTER (id));
			
			gtk_widget_show_all (pMenu);
			gtk_menu_popup (GTK_MENU (pMenu),
				NULL,
				NULL,
				NULL,  // popup on mouse.
				NULL,
				1,
				gtk_get_current_event_time ());
		}
	}
	return FALSE;
}
Пример #19
0
static void __attribute__((constructor)) swh_init() {
	char **port_names;
	LADSPA_PortDescriptor *port_descriptors;
	LADSPA_PortRangeHint *port_range_hints;

#ifdef ENABLE_NLS
#define D_(s) dgettext(PACKAGE, s)
	bindtextdomain(PACKAGE, PACKAGE_LOCALE_DIR);
#else
#define D_(s) (s)
#endif


	declipDescriptor =
	 (LADSPA_Descriptor *)malloc(sizeof(LADSPA_Descriptor));

	if (declipDescriptor) {
		declipDescriptor->UniqueID = 1195;
		declipDescriptor->Label = "declip";
		declipDescriptor->Properties =
		 LADSPA_PROPERTY_HARD_RT_CAPABLE;
		declipDescriptor->Name =
		 D_("Declipper");
		declipDescriptor->Maker =
		 "Steve Harris <*****@*****.**>";
		declipDescriptor->Copyright =
		 "GPL";
		declipDescriptor->PortCount = 2;

		port_descriptors = (LADSPA_PortDescriptor *)calloc(2,
		 sizeof(LADSPA_PortDescriptor));
		declipDescriptor->PortDescriptors =
		 (const LADSPA_PortDescriptor *)port_descriptors;

		port_range_hints = (LADSPA_PortRangeHint *)calloc(2,
		 sizeof(LADSPA_PortRangeHint));
		declipDescriptor->PortRangeHints =
		 (const LADSPA_PortRangeHint *)port_range_hints;

		port_names = (char **)calloc(2, sizeof(char*));
		declipDescriptor->PortNames =
		 (const char **)port_names;

		/* Parameters for Input */
		port_descriptors[DECLIP_INPUT] =
		 LADSPA_PORT_INPUT | LADSPA_PORT_AUDIO;
		port_names[DECLIP_INPUT] =
		 D_("Input");
		port_range_hints[DECLIP_INPUT].HintDescriptor =
		 LADSPA_HINT_BOUNDED_BELOW | LADSPA_HINT_BOUNDED_ABOVE;
		port_range_hints[DECLIP_INPUT].LowerBound = -1;
		port_range_hints[DECLIP_INPUT].UpperBound = +1;

		/* Parameters for Output */
		port_descriptors[DECLIP_OUTPUT] =
		 LADSPA_PORT_OUTPUT | LADSPA_PORT_AUDIO;
		port_names[DECLIP_OUTPUT] =
		 D_("Output");
		port_range_hints[DECLIP_OUTPUT].HintDescriptor =
		 LADSPA_HINT_BOUNDED_BELOW | LADSPA_HINT_BOUNDED_ABOVE;
		port_range_hints[DECLIP_OUTPUT].LowerBound = -1;
		port_range_hints[DECLIP_OUTPUT].UpperBound = +1;

		declipDescriptor->activate = NULL;
		declipDescriptor->cleanup = cleanupDeclip;
		declipDescriptor->connect_port = connectPortDeclip;
		declipDescriptor->deactivate = NULL;
		declipDescriptor->instantiate = instantiateDeclip;
		declipDescriptor->run = runDeclip;
		declipDescriptor->run_adding = runAddingDeclip;
		declipDescriptor->set_run_adding_gain = setRunAddingGainDeclip;
	}
}
Пример #20
0
static GtkWidget *cd_build_events_widget (void)
{
	GtkWidget *pMainBox = gtk_box_new (GTK_ORIENTATION_VERTICAL, MARGIN);
	
	// category toolbar.
	GtkWidget *pToolBar = gtk_toolbar_new ();
	///gtk_toolbar_set_orientation (GTK_TOOLBAR (pToolBar), GTK_ORIENTATION_HORIZONTAL);
	gtk_toolbar_set_style (GTK_TOOLBAR (pToolBar), GTK_TOOLBAR_BOTH);  // overwrite system preference (GTK_TOOLBAR_ICONS)

	gtk_style_context_add_class (gtk_widget_get_style_context (pToolBar),
		GTK_STYLE_CLASS_INLINE_TOOLBAR); // style: inline
	GtkCssProvider *css = gtk_css_provider_new (); // but without border
	gtk_css_provider_load_from_data (css, ".inline-toolbar.toolbar { "
		"background: transparent; border-color: transparent; }", -1, NULL);
	GtkStyleContext *ctx = gtk_widget_get_style_context (pToolBar);
	gtk_style_context_add_provider (ctx, GTK_STYLE_PROVIDER (css),
		GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);

	gtk_toolbar_set_show_arrow (GTK_TOOLBAR (pToolBar), FALSE);  // force to display all the entries.
	gtk_box_pack_start (GTK_BOX (pMainBox), pToolBar, TRUE, TRUE, MARGIN);
	
	int i = 0;
	GtkToolItem *group = _add_category_button (pToolBar, D_("All"), "stock_search", i++, NULL);
	_add_category_button (pToolBar, D_("Applications"), "exec", i++, group);
	_add_category_button (pToolBar, D_("Documents"), "document", i++, group);
	///_add_category_button (pToolBar, D_("Folders"), "folder", i++, group);
	_add_category_button (pToolBar, D_("Images"), "image", i++, group);
	_add_category_button (pToolBar, D_("Audio"), "sound", i++, group);
	_add_category_button (pToolBar, D_("Videos"), "video", i++, group);
	_add_category_button (pToolBar, D_("Web"), "text-html", i++, group);
	_add_category_button (pToolBar, D_("Others"), "unknown", i++, group);
	_add_category_button (pToolBar, D_("Top Results"), "gtk-about", i, group);
	
	// search entry.
	GtkWidget *pFilterBox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, CAIRO_DOCK_GUI_MARGIN);
	gtk_box_pack_start (GTK_BOX (pMainBox), pFilterBox, FALSE, FALSE, MARGIN);
	
	GtkWidget *pFilterLabel = gtk_label_new (D_("Look for events"));
	gldi_dialog_set_widget_text_color (GTK_WIDGET (pFilterLabel));
	gtk_box_pack_start (GTK_BOX (pFilterBox), pFilterLabel, FALSE, FALSE, MARGIN);
	
	GtkWidget *pEntry = gtk_entry_new ();
	// press any key:
	g_signal_connect (pEntry, "key-release-event", G_CALLBACK (on_key_press_filter), NULL);
	gtk_box_pack_start (GTK_BOX (pFilterBox), pEntry, TRUE, TRUE, MARGIN);
	gtk_widget_set_tooltip_text (pEntry, D_("The default boolean operator is AND. Thus the query foo bar will be interpreted as foo AND bar. To exclude a term from the result set prepend it with a minus sign - eg foo -bar. Phrase queries can be done by double quoting the string \"foo is a bar\". You can truncate terms by appending a *. "));

	gtk_entry_set_icon_activatable (GTK_ENTRY (pEntry), GTK_ENTRY_ICON_SECONDARY, TRUE);
	gtk_entry_set_icon_from_icon_name (GTK_ENTRY (pEntry), GTK_ENTRY_ICON_SECONDARY, GLDI_ICON_NAME_CLEAR);
	g_signal_connect (pEntry, "icon-press", G_CALLBACK (on_clear_filter), NULL);

	myData.pEntry = pEntry;
	gtk_widget_grab_focus (pEntry);
	
	// model
	GtkListStore *pModel = gtk_list_store_new (CD_MODEL_NB_COLUMNS,
		G_TYPE_STRING,  /* CD_MODEL_NAME */
		G_TYPE_STRING,  /* CD_MODEL_URI */
		G_TYPE_STRING,  /* CD_MODEL_PATH */
		GDK_TYPE_PIXBUF,  /* CD_MODEL_ICON */
		G_TYPE_INT64,  /* CD_MODEL_DATE */
		G_TYPE_UINT);  /* CD_MODEL_ID */
	myData.pModel = pModel;
	
	// tree-view
	GtkWidget *pOneWidget = gtk_tree_view_new ();
	gtk_tree_view_set_model (GTK_TREE_VIEW (pOneWidget), GTK_TREE_MODEL (pModel));
	gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (pOneWidget), TRUE);
	gtk_tree_view_set_headers_clickable (GTK_TREE_VIEW (pOneWidget), TRUE);
	GtkTreeSelection *selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (pOneWidget));
	gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);
	/**gtk_tree_selection_set_select_function (selection,
		(GtkTreeSelectionFunc) _cairo_dock_select_one_item_in_tree,
		NULL,
		NULL);*/
	g_signal_connect (G_OBJECT (pOneWidget), "button-release-event", G_CALLBACK (_on_click_module_tree_view), NULL);  // pour le menu du clic droit
	g_signal_connect (G_OBJECT (pOneWidget), "button-press-event", G_CALLBACK (_on_click_module_tree_view), NULL);  // pour le menu du clic droit
	
	g_object_set (G_OBJECT (pOneWidget), "tooltip-column", CD_MODEL_PATH, NULL);
	
	GtkTreeViewColumn* col;
	GtkCellRenderer *rend;
	// icon
	rend = gtk_cell_renderer_pixbuf_new ();
	gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (pOneWidget), -1, NULL, rend, "pixbuf", CD_MODEL_ICON, NULL);
	// file name
	rend = gtk_cell_renderer_text_new ();
	col = gtk_tree_view_column_new_with_attributes (D_("File name"), rend, "text", CD_MODEL_NAME, NULL);
	gtk_tree_view_column_set_min_width (col, 200);
	gtk_tree_view_column_set_max_width (col, MAX (500, g_desktopGeometry.Xscreen.width / g_desktopGeometry.iNbScreens * .67));  // we don't know on which screen is place the container...
	gtk_tree_view_column_set_sort_column_id (col, CD_MODEL_NAME);
	gtk_tree_view_append_column (GTK_TREE_VIEW (pOneWidget), col);
	// date
	rend = gtk_cell_renderer_text_new ();
	col = gtk_tree_view_column_new_with_attributes (D_("Last access"), rend, "text", CD_MODEL_DATE, NULL);
	gtk_tree_view_column_set_cell_data_func (col, rend, (GtkTreeCellDataFunc)_render_date, NULL, NULL);
	gtk_tree_view_column_set_sort_column_id (col, CD_MODEL_DATE);
	gtk_tree_view_append_column (GTK_TREE_VIEW (pOneWidget), col);
	
	// barres de defilement
	GtkAdjustment *adj = gtk_adjustment_new (0., 0., 100., 1, 10, 10);
	gtk_scrollable_set_vadjustment (GTK_SCROLLABLE (pOneWidget), GTK_ADJUSTMENT (adj));

	GtkWidget *pScrolledWindow = gtk_scrolled_window_new (NULL, NULL);
	g_object_set (pScrolledWindow, "height-request", 300, NULL);
	gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (pScrolledWindow), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
	#if GTK_CHECK_VERSION (3, 8, 0)
	gtk_container_add (GTK_CONTAINER (pScrolledWindow), pOneWidget);
	#else
	gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (pScrolledWindow), pOneWidget);
	#endif
	gtk_box_pack_start (GTK_BOX (pMainBox), pScrolledWindow, FALSE, FALSE, MARGIN);

	return pMainBox;
}
Пример #21
0
static const char *
_gc_label (E_Gadcon_Client_Class *client_class)
{
  return D_ ("MPDule");
}
Пример #22
0
void _init() {
	char **port_names;
	LADSPA_PortDescriptor *port_descriptors;
	LADSPA_PortRangeHint *port_range_hints;

#ifdef ENABLE_NLS
#define D_(s) dgettext(PACKAGE, s)
	setlocale(LC_ALL, "");
	bindtextdomain(PACKAGE, PACKAGE_LOCALE_DIR);
#else
#define D_(s) (s)
#endif


	sc4Descriptor =
	 (LADSPA_Descriptor *)malloc(sizeof(LADSPA_Descriptor));

	if (sc4Descriptor) {
		sc4Descriptor->UniqueID = 1882;
		sc4Descriptor->Label = "sc4";
		sc4Descriptor->Properties =
		 LADSPA_PROPERTY_HARD_RT_CAPABLE;
		sc4Descriptor->Name =
		 D_("SC4");
		sc4Descriptor->Maker =
		 "Steve Harris <*****@*****.**>";
		sc4Descriptor->Copyright =
		 "GPL";
		sc4Descriptor->PortCount = 13;

		port_descriptors = (LADSPA_PortDescriptor *)calloc(13,
		 sizeof(LADSPA_PortDescriptor));
		sc4Descriptor->PortDescriptors =
		 (const LADSPA_PortDescriptor *)port_descriptors;

		port_range_hints = (LADSPA_PortRangeHint *)calloc(13,
		 sizeof(LADSPA_PortRangeHint));
		sc4Descriptor->PortRangeHints =
		 (const LADSPA_PortRangeHint *)port_range_hints;

		port_names = (char **)calloc(13, sizeof(char*));
		sc4Descriptor->PortNames =
		 (const char **)port_names;

		/* Parameters for RMS/peak */
		port_descriptors[SC4_RMS_PEAK] =
		 LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
		port_names[SC4_RMS_PEAK] =
		 D_("RMS/peak");
		port_range_hints[SC4_RMS_PEAK].HintDescriptor =
		 LADSPA_HINT_BOUNDED_BELOW | LADSPA_HINT_BOUNDED_ABOVE | LADSPA_HINT_DEFAULT_MINIMUM;
		port_range_hints[SC4_RMS_PEAK].LowerBound = 0;
		port_range_hints[SC4_RMS_PEAK].UpperBound = 1;

		/* Parameters for Attack time (ms) */
		port_descriptors[SC4_ATTACK] =
		 LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
		port_names[SC4_ATTACK] =
		 D_("Attack time (ms)");
		port_range_hints[SC4_ATTACK].HintDescriptor =
		 LADSPA_HINT_BOUNDED_BELOW | LADSPA_HINT_BOUNDED_ABOVE | LADSPA_HINT_DEFAULT_LOW;
		port_range_hints[SC4_ATTACK].LowerBound = 1.5;
		port_range_hints[SC4_ATTACK].UpperBound = 400;

		/* Parameters for Release time (ms) */
		port_descriptors[SC4_RELEASE] =
		 LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
		port_names[SC4_RELEASE] =
		 D_("Release time (ms)");
		port_range_hints[SC4_RELEASE].HintDescriptor =
		 LADSPA_HINT_BOUNDED_BELOW | LADSPA_HINT_BOUNDED_ABOVE | LADSPA_HINT_DEFAULT_MIDDLE;
		port_range_hints[SC4_RELEASE].LowerBound = 2;
		port_range_hints[SC4_RELEASE].UpperBound = 800;

		/* Parameters for Threshold level (dB) */
		port_descriptors[SC4_THRESHOLD] =
		 LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
		port_names[SC4_THRESHOLD] =
		 D_("Threshold level (dB)");
		port_range_hints[SC4_THRESHOLD].HintDescriptor =
		 LADSPA_HINT_BOUNDED_BELOW | LADSPA_HINT_BOUNDED_ABOVE | LADSPA_HINT_DEFAULT_MAXIMUM;
		port_range_hints[SC4_THRESHOLD].LowerBound = -30;
		port_range_hints[SC4_THRESHOLD].UpperBound = 0;

		/* Parameters for Ratio (1:n) */
		port_descriptors[SC4_RATIO] =
		 LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
		port_names[SC4_RATIO] =
		 D_("Ratio (1:n)");
		port_range_hints[SC4_RATIO].HintDescriptor =
		 LADSPA_HINT_BOUNDED_BELOW | LADSPA_HINT_BOUNDED_ABOVE | LADSPA_HINT_DEFAULT_1;
		port_range_hints[SC4_RATIO].LowerBound = 1;
		port_range_hints[SC4_RATIO].UpperBound = 10;

		/* Parameters for Knee radius (dB) */
		port_descriptors[SC4_KNEE] =
		 LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
		port_names[SC4_KNEE] =
		 D_("Knee radius (dB)");
		port_range_hints[SC4_KNEE].HintDescriptor =
		 LADSPA_HINT_BOUNDED_BELOW | LADSPA_HINT_BOUNDED_ABOVE | LADSPA_HINT_DEFAULT_LOW;
		port_range_hints[SC4_KNEE].LowerBound = 1;
		port_range_hints[SC4_KNEE].UpperBound = 10;

		/* Parameters for Makeup gain (dB) */
		port_descriptors[SC4_MAKEUP_GAIN] =
		 LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
		port_names[SC4_MAKEUP_GAIN] =
		 D_("Makeup gain (dB)");
		port_range_hints[SC4_MAKEUP_GAIN].HintDescriptor =
		 LADSPA_HINT_BOUNDED_BELOW | LADSPA_HINT_BOUNDED_ABOVE | LADSPA_HINT_DEFAULT_0;
		port_range_hints[SC4_MAKEUP_GAIN].LowerBound = 0;
		port_range_hints[SC4_MAKEUP_GAIN].UpperBound = +24;

		/* Parameters for Amplitude (dB) */
		port_descriptors[SC4_AMPLITUDE] =
		 LADSPA_PORT_OUTPUT | LADSPA_PORT_CONTROL;
		port_names[SC4_AMPLITUDE] =
		 D_("Amplitude (dB)");
		port_range_hints[SC4_AMPLITUDE].HintDescriptor =
		 LADSPA_HINT_BOUNDED_BELOW | LADSPA_HINT_BOUNDED_ABOVE;
		port_range_hints[SC4_AMPLITUDE].LowerBound = -40;
		port_range_hints[SC4_AMPLITUDE].UpperBound = +12;

		/* Parameters for Gain reduction (dB) */
		port_descriptors[SC4_GAIN_RED] =
		 LADSPA_PORT_OUTPUT | LADSPA_PORT_CONTROL;
		port_names[SC4_GAIN_RED] =
		 D_("Gain reduction (dB)");
		port_range_hints[SC4_GAIN_RED].HintDescriptor =
		 LADSPA_HINT_BOUNDED_BELOW | LADSPA_HINT_BOUNDED_ABOVE;
		port_range_hints[SC4_GAIN_RED].LowerBound = 0;
		port_range_hints[SC4_GAIN_RED].UpperBound = 24;

		/* Parameters for Left input */
		port_descriptors[SC4_LEFT_IN] =
		 LADSPA_PORT_INPUT | LADSPA_PORT_AUDIO;
		port_names[SC4_LEFT_IN] =
		 D_("Left input");
		port_range_hints[SC4_LEFT_IN].HintDescriptor = 0;

		/* Parameters for Right input */
		port_descriptors[SC4_RIGHT_IN] =
		 LADSPA_PORT_INPUT | LADSPA_PORT_AUDIO;
		port_names[SC4_RIGHT_IN] =
		 D_("Right input");
		port_range_hints[SC4_RIGHT_IN].HintDescriptor = 0;

		/* Parameters for Left output */
		port_descriptors[SC4_LEFT_OUT] =
		 LADSPA_PORT_OUTPUT | LADSPA_PORT_AUDIO;
		port_names[SC4_LEFT_OUT] =
		 D_("Left output");
		port_range_hints[SC4_LEFT_OUT].HintDescriptor = 0;

		/* Parameters for Right output */
		port_descriptors[SC4_RIGHT_OUT] =
		 LADSPA_PORT_OUTPUT | LADSPA_PORT_AUDIO;
		port_names[SC4_RIGHT_OUT] =
		 D_("Right output");
		port_range_hints[SC4_RIGHT_OUT].HintDescriptor = 0;

		sc4Descriptor->activate = NULL;
		sc4Descriptor->cleanup = cleanupSc4;
		sc4Descriptor->connect_port = connectPortSc4;
		sc4Descriptor->deactivate = NULL;
		sc4Descriptor->instantiate = instantiateSc4;
		sc4Descriptor->run = runSc4;
		sc4Descriptor->run_adding = runAddingSc4;
		sc4Descriptor->set_run_adding_gain = setRunAddingGainSc4;
	}
}
Пример #23
0
void _init() {
    char **port_names;
    LADSPA_PortDescriptor *port_descriptors;
    LADSPA_PortRangeHint *port_range_hints;

#define D_(s) (s)


    jaminControllerDescriptor =
        (LADSPA_Descriptor *)malloc(sizeof(LADSPA_Descriptor));

    if (jaminControllerDescriptor) {
        jaminControllerDescriptor->UniqueID = 1912;
        jaminControllerDescriptor->Label = "jaminController";
        jaminControllerDescriptor->Properties =
            LADSPA_PROPERTY_HARD_RT_CAPABLE;
        jaminControllerDescriptor->Name =
            D_("JAMin Controller");
        jaminControllerDescriptor->Maker =
            "Steve Harris <*****@*****.**>";
        jaminControllerDescriptor->Copyright =
            "GPL";
        jaminControllerDescriptor->PortCount = 3;

        port_descriptors = (LADSPA_PortDescriptor *)calloc(3,
                           sizeof(LADSPA_PortDescriptor));
        jaminControllerDescriptor->PortDescriptors =
            (const LADSPA_PortDescriptor *)port_descriptors;

        port_range_hints = (LADSPA_PortRangeHint *)calloc(3,
                           sizeof(LADSPA_PortRangeHint));
        jaminControllerDescriptor->PortRangeHints =
            (const LADSPA_PortRangeHint *)port_range_hints;

        port_names = (char **)calloc(3, sizeof(char*));
        jaminControllerDescriptor->PortNames =
            (const char **)port_names;

        /* Parameters for Scene no. */
        port_descriptors[JAMINCONTROLLER_SCENE_CONT] =
            LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
        port_names[JAMINCONTROLLER_SCENE_CONT] =
            D_("Scene no.");
        port_range_hints[JAMINCONTROLLER_SCENE_CONT].HintDescriptor =
            LADSPA_HINT_BOUNDED_BELOW | LADSPA_HINT_BOUNDED_ABOVE | LADSPA_HINT_DEFAULT_1 | LADSPA_HINT_INTEGER;
        port_range_hints[JAMINCONTROLLER_SCENE_CONT].LowerBound = 1;
        port_range_hints[JAMINCONTROLLER_SCENE_CONT].UpperBound = NUM_SCENES;

        /* Parameters for Input */
        port_descriptors[JAMINCONTROLLER_INPUT] =
            LADSPA_PORT_INPUT | LADSPA_PORT_AUDIO;
        port_names[JAMINCONTROLLER_INPUT] =
            D_("Input");
        port_range_hints[JAMINCONTROLLER_INPUT].HintDescriptor = 0;

        /* Parameters for Output */
        port_descriptors[JAMINCONTROLLER_OUTPUT] =
            LADSPA_PORT_OUTPUT | LADSPA_PORT_AUDIO;
        port_names[JAMINCONTROLLER_OUTPUT] =
            D_("Output");
        port_range_hints[JAMINCONTROLLER_OUTPUT].HintDescriptor = 0;

        jaminControllerDescriptor->activate = activateJaminController;
        jaminControllerDescriptor->cleanup = cleanupJaminController;
        jaminControllerDescriptor->connect_port = connectPortJaminController;
        jaminControllerDescriptor->deactivate = NULL;
        jaminControllerDescriptor->instantiate = instantiateJaminController;
        jaminControllerDescriptor->run = runJaminController;
        jaminControllerDescriptor->run_adding = runAddingJaminController;
        jaminControllerDescriptor->set_run_adding_gain = setRunAddingGainJaminController;
    }
}
Пример #24
0
static void get_pbod(struct module_data *m, int size, xmp_file f, void *parm)
{
    struct xmp_module *mod = &m->mod;
    struct local_data *data = (struct local_data *)parm;

    int j;
    uint16 rows;
    struct xmp_event *event;

    if (data->pattern >= mod->pat)
	return;

    if (!data->pattern) {
	PATTERN_INIT();
	D_(D_INFO "Stored patterns: %d", mod->pat);
    }

    rows = read16b(f);

    PATTERN_ALLOC(data->pattern);
    mod->xxp[data->pattern]->rows = rows;
    TRACK_ALLOC(data->pattern);

    for (j = 0; j < rows * mod->chn; j++) {
	uint8 note, ins;

	event = &EVENT(data->pattern, j % mod->chn, j / mod->chn);
	memset(event, 0, sizeof(struct xmp_event));

	note = read8(f);
	ins = read8(f);

	if (note) {
	    event->note = 48 + note;
	    event->ins = 1 + ins;
	}

	event->fxt = fx[read8(f)];
	event->fxp = read8(f);

	if ((event->fxt == FX_VOLSET) && (event->fxp > 0x40)) {
	    if (event->fxp <= 0x50) {
		event->fxt = FX_VOLSLIDE;
		event->fxp -= 0x40;
	    } else if (event->fxp <= 0x60) {
		event->fxt = FX_VOLSLIDE;
		event->fxp = (event->fxp - 0x50) << 4;
	    } else if (event->fxp <= 0x70) {
		event->fxt = FX_EXTENDED;
		event->fxp = (EX_F_VSLIDE_DN << 4) | (event->fxp - 0x60);
	    } else if (event->fxp <= 0x80) {
		event->fxt = FX_EXTENDED;
		event->fxp = (EX_F_VSLIDE_UP << 4) | (event->fxp - 0x70);
	    }
	}
	if (event->fxt == FX_ARPEGGIO)	/* Arpeggio fixup */
	    event->fxp = (((24 - MSN (event->fxp)) % 12) << 4) | LSN (event->fxp);
	if (event->fxt == NONE)
	    event->fxt = event->fxp = 0;
    }
    data->pattern++;
}
Пример #25
0
static void __attribute__((constructor)) swh_init() {
	char **port_names;
	LADSPA_PortDescriptor *port_descriptors;
	LADSPA_PortRangeHint *port_range_hints;

#ifdef ENABLE_NLS
#define D_(s) dgettext(PACKAGE, s)
	bindtextdomain(PACKAGE, PACKAGE_LOCALE_DIR);
#else
#define D_(s) (s)
#endif


	gsmDescriptor =
	 (LADSPA_Descriptor *)malloc(sizeof(LADSPA_Descriptor));

	if (gsmDescriptor) {
		gsmDescriptor->UniqueID = 1215;
		gsmDescriptor->Label = "gsm";
		gsmDescriptor->Properties =
		 0;
		gsmDescriptor->Name =
		 D_("GSM simulator");
		gsmDescriptor->Maker =
		 "Steve Harris <*****@*****.**>";
		gsmDescriptor->Copyright =
		 "GPL";
		gsmDescriptor->PortCount = 6;

		port_descriptors = (LADSPA_PortDescriptor *)calloc(6,
		 sizeof(LADSPA_PortDescriptor));
		gsmDescriptor->PortDescriptors =
		 (const LADSPA_PortDescriptor *)port_descriptors;

		port_range_hints = (LADSPA_PortRangeHint *)calloc(6,
		 sizeof(LADSPA_PortRangeHint));
		gsmDescriptor->PortRangeHints =
		 (const LADSPA_PortRangeHint *)port_range_hints;

		port_names = (char **)calloc(6, sizeof(char*));
		gsmDescriptor->PortNames =
		 (const char **)port_names;

		/* Parameters for Dry/wet mix */
		port_descriptors[GSM_DRYWET] =
		 LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
		port_names[GSM_DRYWET] =
		 D_("Dry/wet mix");
		port_range_hints[GSM_DRYWET].HintDescriptor =
		 LADSPA_HINT_BOUNDED_BELOW | LADSPA_HINT_BOUNDED_ABOVE | LADSPA_HINT_DEFAULT_1;
		port_range_hints[GSM_DRYWET].LowerBound = 0;
		port_range_hints[GSM_DRYWET].UpperBound = 1;

		/* Parameters for Number of passes */
		port_descriptors[GSM_PASSES] =
		 LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
		port_names[GSM_PASSES] =
		 D_("Number of passes");
		port_range_hints[GSM_PASSES].HintDescriptor =
		 LADSPA_HINT_BOUNDED_BELOW | LADSPA_HINT_BOUNDED_ABOVE | LADSPA_HINT_INTEGER | LADSPA_HINT_DEFAULT_1;
		port_range_hints[GSM_PASSES].LowerBound = 0;
		port_range_hints[GSM_PASSES].UpperBound = 10;

		/* Parameters for Error rate (bits/block) */
		port_descriptors[GSM_ERROR] =
		 LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
		port_names[GSM_ERROR] =
		 D_("Error rate (bits/block)");
		port_range_hints[GSM_ERROR].HintDescriptor =
		 LADSPA_HINT_BOUNDED_BELOW | LADSPA_HINT_BOUNDED_ABOVE | LADSPA_HINT_DEFAULT_0;
		port_range_hints[GSM_ERROR].LowerBound = 0;
		port_range_hints[GSM_ERROR].UpperBound = 30;

		/* Parameters for Input */
		port_descriptors[GSM_INPUT] =
		 LADSPA_PORT_INPUT | LADSPA_PORT_AUDIO;
		port_names[GSM_INPUT] =
		 D_("Input");
		port_range_hints[GSM_INPUT].HintDescriptor = 0;

		/* Parameters for Output */
		port_descriptors[GSM_OUTPUT] =
		 LADSPA_PORT_OUTPUT | LADSPA_PORT_AUDIO;
		port_names[GSM_OUTPUT] =
		 D_("Output");
		port_range_hints[GSM_OUTPUT].HintDescriptor = 0;

		/* Parameters for latency */
		port_descriptors[GSM_LATENCY] =
		 LADSPA_PORT_OUTPUT | LADSPA_PORT_CONTROL;
		port_names[GSM_LATENCY] =
		 D_("latency");
		port_range_hints[GSM_LATENCY].HintDescriptor = 0;

		gsmDescriptor->activate = activateGsm;
		gsmDescriptor->cleanup = cleanupGsm;
		gsmDescriptor->connect_port = connectPortGsm;
		gsmDescriptor->deactivate = NULL;
		gsmDescriptor->instantiate = instantiateGsm;
		gsmDescriptor->run = runGsm;
		gsmDescriptor->run_adding = runAddingGsm;
		gsmDescriptor->set_run_adding_gain = setRunAddingGainGsm;
	}
}
Пример #26
0
void __attribute__((constructor)) swh_init() {
	char **port_names;
	LADSPA_PortDescriptor *port_descriptors;
	LADSPA_PortRangeHint *port_range_hints;

#ifdef ENABLE_NLS
#define D_(s) dgettext(PACKAGE, s)
	setlocale(LC_ALL, "");
	bindtextdomain(PACKAGE, PACKAGE_LOCALE_DIR);
#else
#define D_(s) (s)
#endif


	sinCosDescriptor =
	 (LADSPA_Descriptor *)malloc(sizeof(LADSPA_Descriptor));

	if (sinCosDescriptor) {
		sinCosDescriptor->UniqueID = 1881;
		sinCosDescriptor->Label = "sinCos";
		sinCosDescriptor->Properties =
		 LADSPA_PROPERTY_HARD_RT_CAPABLE;
		sinCosDescriptor->Name =
		 D_("Sine + cosine oscillator");
		sinCosDescriptor->Maker =
		 "Steve Harris <*****@*****.**>";
		sinCosDescriptor->Copyright =
		 "GPL";
		sinCosDescriptor->PortCount = 4;

		port_descriptors = (LADSPA_PortDescriptor *)calloc(4,
		 sizeof(LADSPA_PortDescriptor));
		sinCosDescriptor->PortDescriptors =
		 (const LADSPA_PortDescriptor *)port_descriptors;

		port_range_hints = (LADSPA_PortRangeHint *)calloc(4,
		 sizeof(LADSPA_PortRangeHint));
		sinCosDescriptor->PortRangeHints =
		 (const LADSPA_PortRangeHint *)port_range_hints;

		port_names = (char **)calloc(4, sizeof(char*));
		sinCosDescriptor->PortNames =
		 (const char **)port_names;

		/* Parameters for Base frequency (Hz) */
		port_descriptors[SINCOS_FREQ] =
		 LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
		port_names[SINCOS_FREQ] =
		 D_("Base frequency (Hz)");
		port_range_hints[SINCOS_FREQ].HintDescriptor =
		 LADSPA_HINT_BOUNDED_BELOW | LADSPA_HINT_BOUNDED_ABOVE | LADSPA_HINT_DEFAULT_440 | LADSPA_HINT_SAMPLE_RATE | LADSPA_HINT_LOGARITHMIC;
		port_range_hints[SINCOS_FREQ].LowerBound = 0.000001;
		port_range_hints[SINCOS_FREQ].UpperBound = 0.5;

		/* Parameters for Pitch offset */
		port_descriptors[SINCOS_PITCH] =
		 LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
		port_names[SINCOS_PITCH] =
		 D_("Pitch offset");
		port_range_hints[SINCOS_PITCH].HintDescriptor =
		 LADSPA_HINT_BOUNDED_BELOW | LADSPA_HINT_BOUNDED_ABOVE | LADSPA_HINT_DEFAULT_0;
		port_range_hints[SINCOS_PITCH].LowerBound = 0;
		port_range_hints[SINCOS_PITCH].UpperBound = 8;

		/* Parameters for Sine output */
		port_descriptors[SINCOS_SINE] =
		 LADSPA_PORT_OUTPUT | LADSPA_PORT_AUDIO;
		port_names[SINCOS_SINE] =
		 D_("Sine output");
		port_range_hints[SINCOS_SINE].HintDescriptor = 0;

		/* Parameters for Cosine output */
		port_descriptors[SINCOS_COSINE] =
		 LADSPA_PORT_OUTPUT | LADSPA_PORT_AUDIO;
		port_names[SINCOS_COSINE] =
		 D_("Cosine output");
		port_range_hints[SINCOS_COSINE].HintDescriptor = 0;

		sinCosDescriptor->activate = NULL;
		sinCosDescriptor->cleanup = cleanupSinCos;
		sinCosDescriptor->connect_port = connectPortSinCos;
		sinCosDescriptor->deactivate = NULL;
		sinCosDescriptor->instantiate = instantiateSinCos;
		sinCosDescriptor->run = runSinCos;
		sinCosDescriptor->run_adding = runAddingSinCos;
		sinCosDescriptor->set_run_adding_gain = setRunAddingGainSinCos;
	}
}
Пример #27
0
void _init() {
	char **port_names;
	LADSPA_PortDescriptor *port_descriptors;
	LADSPA_PortRangeHint *port_range_hints;

#ifdef ENABLE_NLS
#define D_(s) dgettext(PACKAGE, s)
	setlocale(LC_ALL, "");
	bindtextdomain(PACKAGE, PACKAGE_LOCALE_DIR);
#else
#define D_(s) (s)
#endif


	mbeqDescriptor =
	 (LADSPA_Descriptor *)malloc(sizeof(LADSPA_Descriptor));

	if (mbeqDescriptor) {
		mbeqDescriptor->UniqueID = 1197;
		mbeqDescriptor->Label = "mbeq";
		mbeqDescriptor->Properties =
		 LADSPA_PROPERTY_HARD_RT_CAPABLE;
		mbeqDescriptor->Name =
		 D_("Multiband EQ");
		mbeqDescriptor->Maker =
		 "Steve Harris <*****@*****.**>";
		mbeqDescriptor->Copyright =
		 "GPL";
		mbeqDescriptor->PortCount = 18;

		port_descriptors = (LADSPA_PortDescriptor *)calloc(18,
		 sizeof(LADSPA_PortDescriptor));
		mbeqDescriptor->PortDescriptors =
		 (const LADSPA_PortDescriptor *)port_descriptors;

		port_range_hints = (LADSPA_PortRangeHint *)calloc(18,
		 sizeof(LADSPA_PortRangeHint));
		mbeqDescriptor->PortRangeHints =
		 (const LADSPA_PortRangeHint *)port_range_hints;

		port_names = (char **)calloc(18, sizeof(char*));
		mbeqDescriptor->PortNames =
		 (const char **)port_names;

		/* Parameters for 50Hz gain (low shelving) */
		port_descriptors[MBEQ_BAND_1] =
		 LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
		port_names[MBEQ_BAND_1] =
		 D_("50Hz gain (low shelving)");
		port_range_hints[MBEQ_BAND_1].HintDescriptor =
		 LADSPA_HINT_BOUNDED_BELOW | LADSPA_HINT_BOUNDED_ABOVE | LADSPA_HINT_DEFAULT_0;
		port_range_hints[MBEQ_BAND_1].LowerBound = -70;
		port_range_hints[MBEQ_BAND_1].UpperBound = +30;

		/* Parameters for 100Hz gain */
		port_descriptors[MBEQ_BAND_2] =
		 LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
		port_names[MBEQ_BAND_2] =
		 D_("100Hz gain");
		port_range_hints[MBEQ_BAND_2].HintDescriptor =
		 LADSPA_HINT_BOUNDED_BELOW | LADSPA_HINT_BOUNDED_ABOVE | LADSPA_HINT_DEFAULT_0;
		port_range_hints[MBEQ_BAND_2].LowerBound = -70;
		port_range_hints[MBEQ_BAND_2].UpperBound = +30;

		/* Parameters for 156Hz gain */
		port_descriptors[MBEQ_BAND_3] =
		 LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
		port_names[MBEQ_BAND_3] =
		 D_("156Hz gain");
		port_range_hints[MBEQ_BAND_3].HintDescriptor =
		 LADSPA_HINT_BOUNDED_BELOW | LADSPA_HINT_BOUNDED_ABOVE | LADSPA_HINT_DEFAULT_0;
		port_range_hints[MBEQ_BAND_3].LowerBound = -70;
		port_range_hints[MBEQ_BAND_3].UpperBound = +30;

		/* Parameters for 220Hz gain */
		port_descriptors[MBEQ_BAND_4] =
		 LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
		port_names[MBEQ_BAND_4] =
		 D_("220Hz gain");
		port_range_hints[MBEQ_BAND_4].HintDescriptor =
		 LADSPA_HINT_BOUNDED_BELOW | LADSPA_HINT_BOUNDED_ABOVE | LADSPA_HINT_DEFAULT_0;
		port_range_hints[MBEQ_BAND_4].LowerBound = -70;
		port_range_hints[MBEQ_BAND_4].UpperBound = +30;

		/* Parameters for 311Hz gain */
		port_descriptors[MBEQ_BAND_5] =
		 LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
		port_names[MBEQ_BAND_5] =
		 D_("311Hz gain");
		port_range_hints[MBEQ_BAND_5].HintDescriptor =
		 LADSPA_HINT_BOUNDED_BELOW | LADSPA_HINT_BOUNDED_ABOVE | LADSPA_HINT_DEFAULT_0;
		port_range_hints[MBEQ_BAND_5].LowerBound = -70;
		port_range_hints[MBEQ_BAND_5].UpperBound = +30;

		/* Parameters for 440Hz gain */
		port_descriptors[MBEQ_BAND_6] =
		 LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
		port_names[MBEQ_BAND_6] =
		 D_("440Hz gain");
		port_range_hints[MBEQ_BAND_6].HintDescriptor =
		 LADSPA_HINT_BOUNDED_BELOW | LADSPA_HINT_BOUNDED_ABOVE | LADSPA_HINT_DEFAULT_0;
		port_range_hints[MBEQ_BAND_6].LowerBound = -70;
		port_range_hints[MBEQ_BAND_6].UpperBound = +30;

		/* Parameters for 622Hz gain */
		port_descriptors[MBEQ_BAND_7] =
		 LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
		port_names[MBEQ_BAND_7] =
		 D_("622Hz gain");
		port_range_hints[MBEQ_BAND_7].HintDescriptor =
		 LADSPA_HINT_BOUNDED_BELOW | LADSPA_HINT_BOUNDED_ABOVE | LADSPA_HINT_DEFAULT_0;
		port_range_hints[MBEQ_BAND_7].LowerBound = -70;
		port_range_hints[MBEQ_BAND_7].UpperBound = +30;

		/* Parameters for 880Hz gain */
		port_descriptors[MBEQ_BAND_8] =
		 LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
		port_names[MBEQ_BAND_8] =
		 D_("880Hz gain");
		port_range_hints[MBEQ_BAND_8].HintDescriptor =
		 LADSPA_HINT_BOUNDED_BELOW | LADSPA_HINT_BOUNDED_ABOVE | LADSPA_HINT_DEFAULT_0;
		port_range_hints[MBEQ_BAND_8].LowerBound = -70;
		port_range_hints[MBEQ_BAND_8].UpperBound = +30;

		/* Parameters for 1250Hz gain */
		port_descriptors[MBEQ_BAND_9] =
		 LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
		port_names[MBEQ_BAND_9] =
		 D_("1250Hz gain");
		port_range_hints[MBEQ_BAND_9].HintDescriptor =
		 LADSPA_HINT_BOUNDED_BELOW | LADSPA_HINT_BOUNDED_ABOVE | LADSPA_HINT_DEFAULT_0;
		port_range_hints[MBEQ_BAND_9].LowerBound = -70;
		port_range_hints[MBEQ_BAND_9].UpperBound = +30;

		/* Parameters for 1750Hz gain */
		port_descriptors[MBEQ_BAND_10] =
		 LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
		port_names[MBEQ_BAND_10] =
		 D_("1750Hz gain");
		port_range_hints[MBEQ_BAND_10].HintDescriptor =
		 LADSPA_HINT_BOUNDED_BELOW | LADSPA_HINT_BOUNDED_ABOVE | LADSPA_HINT_DEFAULT_0;
		port_range_hints[MBEQ_BAND_10].LowerBound = -70;
		port_range_hints[MBEQ_BAND_10].UpperBound = +30;

		/* Parameters for 2500Hz gain */
		port_descriptors[MBEQ_BAND_11] =
		 LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
		port_names[MBEQ_BAND_11] =
		 D_("2500Hz gain");
		port_range_hints[MBEQ_BAND_11].HintDescriptor =
		 LADSPA_HINT_BOUNDED_BELOW | LADSPA_HINT_BOUNDED_ABOVE | LADSPA_HINT_DEFAULT_0;
		port_range_hints[MBEQ_BAND_11].LowerBound = -70;
		port_range_hints[MBEQ_BAND_11].UpperBound = +30;

		/* Parameters for 3500Hz gain */
		port_descriptors[MBEQ_BAND_12] =
		 LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
		port_names[MBEQ_BAND_12] =
		 D_("3500Hz gain");
		port_range_hints[MBEQ_BAND_12].HintDescriptor =
		 LADSPA_HINT_BOUNDED_BELOW | LADSPA_HINT_BOUNDED_ABOVE | LADSPA_HINT_DEFAULT_0;
		port_range_hints[MBEQ_BAND_12].LowerBound = -70;
		port_range_hints[MBEQ_BAND_12].UpperBound = +30;

		/* Parameters for 5000Hz gain */
		port_descriptors[MBEQ_BAND_13] =
		 LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
		port_names[MBEQ_BAND_13] =
		 D_("5000Hz gain");
		port_range_hints[MBEQ_BAND_13].HintDescriptor =
		 LADSPA_HINT_BOUNDED_BELOW | LADSPA_HINT_BOUNDED_ABOVE | LADSPA_HINT_DEFAULT_0;
		port_range_hints[MBEQ_BAND_13].LowerBound = -70;
		port_range_hints[MBEQ_BAND_13].UpperBound = +30;

		/* Parameters for 10000Hz gain */
		port_descriptors[MBEQ_BAND_14] =
		 LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
		port_names[MBEQ_BAND_14] =
		 D_("10000Hz gain");
		port_range_hints[MBEQ_BAND_14].HintDescriptor =
		 LADSPA_HINT_BOUNDED_BELOW | LADSPA_HINT_BOUNDED_ABOVE | LADSPA_HINT_DEFAULT_0;
		port_range_hints[MBEQ_BAND_14].LowerBound = -70;
		port_range_hints[MBEQ_BAND_14].UpperBound = +30;

		/* Parameters for 20000Hz gain */
		port_descriptors[MBEQ_BAND_15] =
		 LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL;
		port_names[MBEQ_BAND_15] =
		 D_("20000Hz gain");
		port_range_hints[MBEQ_BAND_15].HintDescriptor =
		 LADSPA_HINT_BOUNDED_BELOW | LADSPA_HINT_BOUNDED_ABOVE | LADSPA_HINT_DEFAULT_0;
		port_range_hints[MBEQ_BAND_15].LowerBound = -70;
		port_range_hints[MBEQ_BAND_15].UpperBound = +30;

		/* Parameters for Input */
		port_descriptors[MBEQ_INPUT] =
		 LADSPA_PORT_INPUT | LADSPA_PORT_AUDIO;
		port_names[MBEQ_INPUT] =
		 D_("Input");
		port_range_hints[MBEQ_INPUT].HintDescriptor = 0;

		/* Parameters for Output */
		port_descriptors[MBEQ_OUTPUT] =
		 LADSPA_PORT_OUTPUT | LADSPA_PORT_AUDIO;
		port_names[MBEQ_OUTPUT] =
		 D_("Output");
		port_range_hints[MBEQ_OUTPUT].HintDescriptor = 0;

		/* Parameters for latency */
		port_descriptors[MBEQ_LATENCY] =
		 LADSPA_PORT_OUTPUT | LADSPA_PORT_CONTROL;
		port_names[MBEQ_LATENCY] =
		 D_("latency");
		port_range_hints[MBEQ_LATENCY].HintDescriptor = 0;

		mbeqDescriptor->activate = activateMbeq;
		mbeqDescriptor->cleanup = cleanupMbeq;
		mbeqDescriptor->connect_port = connectPortMbeq;
		mbeqDescriptor->deactivate = NULL;
		mbeqDescriptor->instantiate = instantiateMbeq;
		mbeqDescriptor->run = runMbeq;
		mbeqDescriptor->run_adding = runAddingMbeq;
		mbeqDescriptor->set_run_adding_gain = setRunAddingGainMbeq;
	}
}
Пример #28
0
static int get_pbod(struct module_data *m, int size, HIO_HANDLE *f, void *parm)
{
	struct xmp_module *mod = &m->mod;
	struct local_data *data = (struct local_data *)parm;
	struct xmp_event *e;
	uint16 rows;
	int j;

	if (data->pattern >= mod->pat)
		return 0;

	if (!data->pattern) {
		if (pattern_init(mod) < 0)
			return -1;
		D_(D_INFO "Stored patterns: %d", mod->pat);
	}

	rows = hio_read16b(f);

	if (pattern_tracks_alloc(mod, data->pattern, rows) < 0)
		return -1;

	for (j = 0; j < rows * mod->chn; j++) {
		uint8 note, ins;

		e = &EVENT(data->pattern, j % mod->chn, j / mod->chn);
		memset(e, 0, sizeof(struct xmp_event));

		note = hio_read8(f);
		ins = hio_read8(f);

		if (note) {
			e->note = 48 + note;
			e->ins = 1 + ins;
		}

		e->fxt = fx[hio_read8(f)];
		e->fxp = hio_read8(f);

		if ((e->fxt == FX_VOLSET) && (e->fxp > 0x40)) {
			if (e->fxp <= 0x50) {
				e->fxt = FX_VOLSLIDE;
				e->fxp -= 0x40;
			} else if (e->fxp <= 0x60) {
				e->fxt = FX_VOLSLIDE;
				e->fxp = (e->fxp - 0x50) << 4;
			} else if (e->fxp <= 0x70) {
				e->fxt = FX_F_VSLIDE_DN;
				e->fxp = e->fxp - 0x60;
			} else if (e->fxp <= 0x80) {
				e->fxt = FX_F_VSLIDE_UP;
				e->fxp = e->fxp - 0x70;
			}
		}
		if (e->fxt == FX_ARPEGGIO)	/* Arpeggio fixup */
			e->fxp = (((24 - MSN(e->fxp)) % 12) << 4) | LSN(e->fxp);
		if (e->fxt == NONE)
			e->fxt = e->fxp = 0;
	}
	data->pattern++;

	return 0;
}
Пример #29
0
/**
 * Display default value for an option.
 * @param lineLength
 * @param opt		option(s)
 * @param translation_domain	translation domain
 * @return
 */
static /*@only@*/ /*@null@*/ char *
singleOptionDefaultValue(int lineLength,
		const struct poptOption * opt,
		/*@-paramuse@*/ /* FIX: i18n macros disabled with lclint */
		/*@null@*/ const char * translation_domain)
		/*@=paramuse@*/
	/*@*/
{
    const char * defstr = D_(translation_domain, "default");
    char * le = malloc(4*lineLength + 1);
    char * l = le;

    if (le == NULL) return NULL;	/* XXX can't happen */
/*@-boundswrite@*/
    *le = '\0';
    *le++ = '(';
    strcpy(le, defstr);	le += strlen(le);
    *le++ = ':';
    *le++ = ' ';
    if (opt->arg)	/* XXX programmer error */
    switch (opt->argInfo & POPT_ARG_MASK) {
    case POPT_ARG_VAL:
    case POPT_ARG_INT:
    {	long aLong = *((int *)opt->arg);
	le += sprintf(le, "%ld", aLong);
    }	break;
    case POPT_ARG_LONG:
    {	long aLong = *((long *)opt->arg);
	le += sprintf(le, "%ld", aLong);
    }	break;
    case POPT_ARG_FLOAT:
    {	double aDouble = *((float *)opt->arg);
	le += sprintf(le, "%g", aDouble);
    }	break;
    case POPT_ARG_DOUBLE:
    {	double aDouble = *((double *)opt->arg);
	le += sprintf(le, "%g", aDouble);
    }	break;
    case POPT_ARG_STRING:
    {	const char * s = *(const char **)opt->arg;
	if (s == NULL) {
	    strcpy(le, "null");	le += strlen(le);
	} else {
	    size_t slen = 4*lineLength - (le - l) - sizeof("\"...\")");
	    *le++ = '"';
	    strncpy(le, s, slen); le[slen] = '\0'; le += strlen(le);	
	    if (slen < strlen(s)) {
		strcpy(le, "...");	le += strlen(le);
	    }
	    *le++ = '"';
	}
    }	break;
    case POPT_ARG_NONE:
    default:
	l = _free(l);
	return NULL;
	/*@notreached@*/ break;
    }
    *le++ = ')';
    *le = '\0';
/*@=boundswrite@*/

    return l;
}
Пример #30
0
static int ptdt_load(struct module_data *m, HIO_HANDLE *f, const int start)
{
	struct xmp_module *mod = &m->mod;
	int i, j;
	struct xmp_event *event;
	struct mod_header mh;
	uint8 mod_event[4];

	hio_read(&mh.name, 20, 1, f);
	for (i = 0; i < 31; i++) {
		hio_read(&mh.ins[i].name, 22, 1, f);
		mh.ins[i].size = hio_read16b(f);
		mh.ins[i].finetune = hio_read8(f);
		mh.ins[i].volume = hio_read8(f);
		mh.ins[i].loop_start = hio_read16b(f);
		mh.ins[i].loop_size = hio_read16b(f);
	}
	mh.len = hio_read8(f);
	mh.restart = hio_read8(f);
	hio_read(&mh.order, 128, 1, f);
	hio_read(&mh.magic, 4, 1, f);

	mod->ins = 31;
	mod->smp = mod->ins;
	mod->chn = 4;
	mod->len = mh.len;
	mod->rst = mh.restart;
	memcpy(mod->xxo, mh.order, 128);

	for (i = 0; i < 128; i++) {
		if (mod->xxo[i] > mod->pat)
			mod->pat = mod->xxo[i];
	}

	mod->pat++;
	mod->trk = mod->chn * mod->pat;

	if (libxmp_init_instrument(m) < 0)
		return -1;

	for (i = 0; i < mod->ins; i++) {
		if (libxmp_alloc_subinstrument(mod, i, 1) < 0)
			return -1;

		mod->xxs[i].len = 2 * mh.ins[i].size;
		mod->xxs[i].lps = 2 * mh.ins[i].loop_start;
		mod->xxs[i].lpe = mod->xxs[i].lps + 2 * mh.ins[i].loop_size;
		mod->xxs[i].flg = mh.ins[i].loop_size > 1 ? XMP_SAMPLE_LOOP : 0;

		if (mod->xxs[i].len > 0)
			mod->xxi[i].nsm = 1;

		mod->xxi[i].sub[0].fin = (int8)(mh.ins[i].finetune << 4);
		mod->xxi[i].sub[0].vol = mh.ins[i].volume;
		mod->xxi[i].sub[0].pan = 0x80;
		mod->xxi[i].sub[0].sid = i;
		mod->xxi[i].rls = 0xfff;

		libxmp_instrument_name(mod, i, mh.ins[i].name, 22);

		D_(D_INFO "[%2X] %-22.22s %04x %04x %04x %c V%02x %+d",
				i, mod->xxi[i].name,
				mod->xxs[i].len, mod->xxs[i].lps,
				mod->xxs[i].lpe,
				mh.ins[i].loop_size > 1 ? 'L' : ' ',
				mod->xxi[i].sub[0].vol,
				mod->xxi[i].sub[0].fin >> 4);
	}

	if (libxmp_init_pattern(mod) < 0)
		return -1;

	/* Load and convert patterns */
	D_(D_INFO "Stored patterns: %d", mod->pat);

	for (i = 0; i < mod->pat; i++) {
		if (libxmp_alloc_pattern_tracks(mod, i, 64) < 0)
			return -1;

		for (j = 0; j < (64 * 4); j++) {
			event = &EVENT(i, j % 4, j / 4);
			hio_read(mod_event, 1, 4, f);
			libxmp_decode_protracker_event(event, mod_event);
		}
	}

	m->period_type = PERIOD_MODRNG;

	/* Load samples */
	D_(D_INFO "Stored samples: %d", mod->smp);

	for (i = 0; i < mod->smp; i++) {
		if (!mod->xxs[i].len)
			continue;

		if (libxmp_load_sample(m, f, 0, &mod->xxs[i], NULL) < 0)
			return -1;
	}

	return 0;
}