Пример #1
0
void
init_song ( void )
{
    if ( ! midi_is_active() )
        setup_jack();

    if ( !( nsm && nsm->is_active() ) )
        song.filename = NULL;

    clear_song();

    if ( nsm && nsm->is_active() )
        save_song( song.filename );
}
Пример #2
0
bool
load_song ( const char *name )
{
    if ( ! midi_is_active() )
        setup_jack();

    MESSAGE( "loading song \"%s\"", name );

    Grid *pattern_grid = pattern_c->grid();
    Grid *phrase_grid = phrase_c->grid();

    pattern_c->grid( NULL );
    phrase_c->grid( NULL );

    if ( ! playlist->load( name ) )
    {
        WARNING( "failed to load song file" );
        goto failed;
    }

    pattern_c->grid( pattern::pattern_by_number( 1 ) );
    phrase_c->grid( phrase::phrase_by_number( 1 ) );

    song.filename = strdup( name );

    song.dirty( false );

    return true;

failed:

    pattern_c->grid( pattern_grid );
    phrase_c->grid( phrase_grid );

    return false;
}
Пример #3
0
int
main ( int argc, char **argv )
{

    printf( "%s %s %s -- %s\n", APP_TITLE, VERSION, "", COPYRIGHT );

    if ( ! Fl::visual( FL_DOUBLE | FL_RGB ) )
    {
        WARNING( "Xdbe not supported, FLTK will fake double buffering." );
    }

    ::signal( SIGTERM, sigterm_handler );
    ::signal( SIGHUP, sigterm_handler );
    ::signal( SIGINT, sigterm_handler );

    config.follow_playhead = true;
    config.record_mode = MERGE;
    song.play_mode = PATTERN;
    song.random.feel = 8;
    song.random.probability = 0.33;

    asprintf( &config.user_config_dir, "%s/%s", getenv( "HOME" ), USER_CONFIG_DIR );
    mkdir( config.user_config_dir, 0777 );

    playlist = new sequence;

    pattern_c = new Canvas;
    phrase_c = new Canvas;
    trigger_c = new Canvas;

    nsm = new NSM_Client;

    song.filename = NULL;
    clear_song();

    pattern::signal_create_destroy.connect( mem_fun( phrase_c,  &Canvas::v_zoom_fit ) );
    pattern::signal_create_destroy.connect( mem_fun( song, &song_settings::set_dirty ) );
    phrase::signal_create_destroy.connect( mem_fun( song, &song_settings::set_dirty ) );

    //
    song.dirty( false );

    init_colors();

    ui = new UI;

    ui->main_window->show( 0, 0 );

    instance_name = strdup( APP_NAME );

    const char *nsm_url = getenv( "NSM_URL" );
    
    if ( nsm_url )
    {
        if ( ! nsm->init( nsm_url ) )
        {
            nsm->announce( APP_NAME, ":switch:dirty:", argv[0] );

            song.signal_dirty.connect( sigc::mem_fun( nsm, &NSM_Client::is_dirty ) );
            song.signal_clean.connect( sigc::mem_fun( nsm, &NSM_Client::is_clean ) );

            // poll so we can keep OSC handlers running in the GUI thread and avoid extra sync
            Fl::add_timeout( NSM_CHECK_INTERVAL, check_nsm, NULL );
        }       
        else
            WARNING( "Error initializing NSM" );
    }
    else
    {
        setup_jack();
        if ( argc > 1 )
        {
            /* maybe a filename on the commandline */
            if ( ! load_song( argv[ 1 ] ) )
                ASSERTION( "Could not load song \"%s\" specified on command line", argv[ 1 ] );
        }
    }

    MESSAGE( "Initializing GUI" );

    Fl::add_check( check_sigterm );

    ui->load_settings();
    ui->run();

    return 0;
}
Пример #4
0
void parse_args (int argc, char **argv, frame_info * frame, int *psy,
        unsigned long *num_samples, char inPath[MAX_NAME_SIZE],
        char outPath[MAX_NAME_SIZE], char **mot_file, char **icy_file)
{
    FLOAT srate;
    int brate;
    frame_header *header = frame->header;
    int err = 0, i = 0;
    long samplerate = 0;

    /* preset defaults */
    inPath[0] = '\0';
    outPath[0] = '\0';
    header->lay = DFLT_LAY;
    switch (DFLT_MOD) {
        case 's':
            header->mode = MPG_MD_STEREO;
            header->mode_ext = 0;
            break;
        case 'd':
            header->mode = MPG_MD_DUAL_CHANNEL;
            header->mode_ext = 0;
            break;
            /* in j-stereo mode, no default header->mode_ext was defined, gave error..
               now  default = 2   added by MFC 14 Dec 1999.  */
        case 'j':
            header->mode = MPG_MD_JOINT_STEREO;
            header->mode_ext = 2;
            break;
        case 'm':
            header->mode = MPG_MD_MONO;
            header->mode_ext = 0;
            break;
        default:
            fprintf (stderr, "%s: Bad mode dflt %c\n", programName, DFLT_MOD);
            abort ();
    }
    *psy = DFLT_PSY;
    if ((header->sampling_frequency =
                SmpFrqIndex ((long) (1000 * DFLT_SFQ), &header->version)) < 0) {
        fprintf (stderr, "%s: bad sfrq default %.2f\n", programName, DFLT_SFQ);
        abort ();
    }
    header->bitrate_index = 14;
    brate = 0;
    switch (DFLT_EMP) {
        case 'n':
            header->emphasis = 0;
            break;
        case '5':
            header->emphasis = 1;
            break;
        case 'c':
            header->emphasis = 3;
            break;
        default:
            fprintf (stderr, "%s: Bad emph dflt %c\n", programName, DFLT_EMP);
            abort ();
    }
    header->copyright = 0;
    header->original = 0;
    header->error_protection = FALSE;
    header->dab_extension = 0;

    glopts.input_select = INPUT_SELECT_WAV;

    /* process args */
    while (++i < argc && err == 0) {
        char c, *token, *arg, *nextArg;
        int argUsed;

        token = argv[i];
        if (*token++ == '-') {
            if (i + 1 < argc)
                nextArg = argv[i + 1];
            else
                nextArg = "";
            argUsed = 0;
            if (!*token) {
                /* The user wants to use stdin and/or stdout. */
                if (inPath[0] == '\0')
                    strncpy (inPath, argv[i], MAX_NAME_SIZE);
                else if (outPath[0] == '\0')
                    strncpy (outPath, argv[i], MAX_NAME_SIZE);
            }
            while ((c = *token++)) {
                if (*token /* NumericQ(token) */ )
                    arg = token;
                else
                    arg = nextArg;
                switch (c) {
                    case 'm':
                        argUsed = 1;
                        if (*arg == 's') {
                            header->mode = MPG_MD_STEREO;
                            header->mode_ext = 0;
                        } else if (*arg == 'd') {
                            header->mode = MPG_MD_DUAL_CHANNEL;
                            header->mode_ext = 0;
                        } else if (*arg == 'j') {
                            header->mode = MPG_MD_JOINT_STEREO;
                        } else if (*arg == 'm') {
                            header->mode = MPG_MD_MONO;
                            header->mode_ext = 0;
                        } else {
                            fprintf (stderr, "%s: -m mode must be s/d/j/m not %s\n",
                                    programName, arg);
                            err = 1;
                        }
                        break;
                    case 'y':
                        *psy = atoi (arg);
                        argUsed = 1;
                        break;

                    case 'L':
                        glopts.show_level = 1;
                        break;

                    case 's':
                        argUsed = 1;
                        srate = atof (arg);
                        /* samplerate = rint( 1000.0 * srate ); $A  */
                        samplerate = (long) ((1000.0 * srate) + 0.5);
                        if ((header->sampling_frequency =
                                    SmpFrqIndex ((long) samplerate, &header->version)) < 0)
                            err = 1;
                        break;

                    case 'j':
                        glopts.input_select = INPUT_SELECT_JACK;
                        break;

                    case 'b':
                        argUsed = 1;
                        brate = atoi (arg);
                        break;
                    case 'd':
                        argUsed = 1;
                        if (*arg == 'n')
                            header->emphasis = 0;
                        else if (*arg == '5')
                            header->emphasis = 1;
                        else if (*arg == 'c')
                            header->emphasis = 3;
                        else {
                            fprintf (stderr, "%s: -d emp must be n/5/c not %s\n", programName,
                                    arg);
                            err = 1;
                        }
                        break;
                    case 'P':
                        argUsed = 1;
                        *mot_file = arg;
                        break;
                    case 'p':
                        argUsed = 1;
                        header->dab_length = atoi(arg);
                        break;
                    case 'c':
                        header->copyright = 1;
                        break;
                    case 'o':
                        header->original = 1;
                        break;
                    case 'e':
                        header->error_protection = TRUE;
                        break;
                    case 'r':
                        glopts.usepadbit = FALSE;
                        header->padding = 0;
                        break;
                    case 'q':
                        argUsed = 1;
                        glopts.quickmode = TRUE;
                        glopts.usepsy = TRUE;
                        glopts.quickcount = atoi (arg);
                        if (glopts.quickcount == 0) {
                            /* just don't use psy model */
                            glopts.usepsy = FALSE;
                            glopts.quickcount = FALSE;
                        }
                        break;
                    case 'a':
                        glopts.downmix = TRUE;
                        header->mode = MPG_MD_MONO;
                        header->mode_ext = 0;
                        break;
                    case 'x':
                        glopts.byteswap = TRUE;
                        break;
                    case 'v':
                        argUsed = 1;
                        glopts.vbr = TRUE;
                        glopts.vbrlevel = atof (arg);
                        glopts.usepadbit = FALSE;	/* don't use padding for VBR */
                        header->padding = 0;
                        /* MFC Feb 2003: in VBR mode, joint stereo doesn't make
                           any sense at the moment, as there are no noisy subbands 
                           according to bits_for_nonoise in vbr mode */
                        header->mode = MPG_MD_STEREO; /* force stereo mode */
                        header->mode_ext = 0;
                        break;
                    case 'V':
                        glopts.input_select = INPUT_SELECT_VLC;
                        break;
                    case 'W':
                        argUsed = 1;
                        *icy_file = arg;
                        break;
                    case 'l':
                        argUsed = 1;
                        glopts.athlevel = atof(arg);
                        break;
                    case 'h':
                        usage ();
                        break;
                    case 'g':
                        glopts.channelswap = TRUE;
                        break;
                    case 't':
                        argUsed = 1;
                        glopts.verbosity = atoi (arg);
                        break;
                    default:
                        fprintf (stderr, "%s: unrec option %c\n", programName, c);
                        err = 1;
                        break;
                }
                if (argUsed) {
                    if (arg == token)
                        token = "";		/* no more from token */
                    else
                        ++i;		/* skip arg we used */
                    arg = "";
                    argUsed = 0;
                }
            }
        } else {
            if (inPath[0] == '\0')
                strcpy (inPath, argv[i]);
            else if (outPath[0] == '\0')
                strcpy (outPath, argv[i]);
            else {
                fprintf (stderr, "%s: excess arg %s\n", programName, argv[i]);
                err = 1;
            }
        }
    }

    /* Always enable DAB mode */
    header->error_protection = TRUE;
    header->dab_extension = 2;
    header->padding = 0;
    glopts.dab = TRUE;

    if (header->dab_extension) {
        /* in 48 kHz */
        /* if the bit rate per channel is less then 56 kbit/s, we have 2 scf-crc */
        /* else we have 4 scf-crc */
        /* in 24 kHz, we have 4 scf-crc, see main loop */
        if (brate / (header->mode == MPG_MD_MONO ? 1 : 2) >= 56)
            header->dab_extension = 4;
    }


    if (err)
        usage ();			/* If err has occured, then call usage() */

    if (glopts.input_select != INPUT_SELECT_JACK && inPath[0] == '\0')
        usage ();			/* If not in jack-mode and no file specified, then call usage() */

    if (outPath[0] == '\0') {
        /* replace old extension with new one, 1992-08-19, 1995-06-12 shn */
        new_ext (inPath, DFLT_EXT, outPath);
    }

    if (glopts.input_select == INPUT_SELECT_JACK) {
        musicin.jack_name = inPath;
        *num_samples = MAX_U_32_NUM;

#if defined(JACK_INPUT)
        setup_jack(header, musicin.jack_name);
#else
        fprintf(stderr, "JACK input not compiled in\n");
        exit(1);
#endif
    }
    else if (glopts.input_select == INPUT_SELECT_WAV) {
        if (!strcmp (inPath, "-")) {
            musicin.wav_input = stdin;		/* read from stdin */
            *num_samples = MAX_U_32_NUM;
        } else {
            if ((musicin.wav_input = fopen (inPath, "rb")) == NULL) {
                fprintf (stderr, "Could not find \"%s\".\n", inPath);
                exit (1);
            }
            parse_input_file (musicin.wav_input, inPath, header, num_samples);
        }
    }
    else if (glopts.input_select == INPUT_SELECT_VLC) {
        if (samplerate == 0) {
            fprintf (stderr, "Samplerate not specified\n");
            exit (1);
        }
        *num_samples = MAX_U_32_NUM;
        int channels = (header->mode == MPG_MD_MONO) ? 1 : 2;
#if defined(VLC_INPUT)
        if (vlc_in_prepare(glopts.verbosity, samplerate, inPath, channels, *icy_file) != 0) {
            fprintf(stderr, "VLC initialisation failed\n");
            exit(1);
        }
#else
        fprintf(stderr, "VLC input not compiled in\n");
        exit(1);
#endif
    }
    else {
        fprintf(stderr, "INVALID INPUT\n");
        exit(1);
    }


    /* check for a valid bitrate */
    if (brate == 0)
        brate = bitrate[header->version][10];

    /* Check to see we have a sane value for the bitrate for this version */
    if ((header->bitrate_index = BitrateIndex (brate, header->version)) < 0)
        err = 1;

    bs.zmq_framesize = 3 * brate;

    /* All options are hunky dory, open the input audio file and
       return to the main drag */
    open_bit_stream_w (&bs, outPath, BUFFER_SIZE);
}