xaplayer.c

一个非常好用的MP3音乐播放控件

        XA_CodecModule module;

        mpeg_codec_module_register(&module);
        decoder_codec_module_register(decoder, &module);
        wave_codec_module_register(&module);
        decoder_codec_module_register(decoder, &module);
#ifdef MODULES_ENABLE_AAC_CODEC
        aac_codec_module_register(&module);
        decoder_codec_module_register(decoder, &module);
#endif
#ifdef MODULES_ENABLE_QDMC_CODEC
        qdmc_codec_module_register(&module);
        decoder_codec_module_register(decoder, &module);
#endif
    }

    /* register the input modules (the registration order is important) */
    {
        XA_InputModule module;

        file_input_module_register(&module);
        decoder_input_module_register(decoder, &module);
    }
    
    /* register the output modules (the registration order is important) */
    {
        XA_OutputModule module;

        file_output_module_register(&module);
        decoder_output_module_register(decoder, &module);
        audio_output_module_register(&module);
        decoder_output_module_register(decoder, &module);
    }

    /* set the notification function */
    decoder->notification_client.client          = decoder;
    decoder->notification_client.notify_progress = cmdline_notify_progress;
    decoder->notification_client.notify_debug    = cmdline_notify_debug;
    decoder->notification_client.notify_error    = cmdline_notify_error;

    /* output parameters */
    Options.output.port                 = 0;
    Options.output.volume               = -1;
    Options.output.name                 = NULL;

    return decoder;
}

/*----------------------------------------------------------------------
|       cmdline_monitor_stream_info
+---------------------------------------------------------------------*/
static void
cmdline_monitor_stream_info(XA_DecoderInfo *decoder)
{
    static unsigned long duration = 0;

    if (decoder->status->info.changed) {

        /* get mime type */
        if (decoder->status->info.mime_type) {
            if (strcmp(decoder->status->info.mime_type, "audio/mpeg") == 0 ||
                strcmp(decoder->status->info.mime_type, "audio/x-mpeg") == 0 ||
                strcmp(decoder->status->info.mime_type, "audio/x-mp3") == 0) {
                /* mpeg stream, we can print extended info */
                long level;
                long layer;
                long mode;
                
                fprintf(stderr, "XAUDIO: stream type = MPEG");
                if (properties_get_integer(decoder->status->info.properties,
                                           XA_MPEG_CODEC_PROPERTY_STREAM_LEVEL,
                                           &level) == XA_SUCCESS) {
                    fprintf(stderr, " %ld", level);
                }
                if (properties_get_integer(decoder->status->info.properties,
                                           XA_MPEG_CODEC_PROPERTY_STREAM_LAYER,
                                           &layer) == XA_SUCCESS) {
                    fprintf(stderr, ", layer %s", LayerStrings[layer]);
                }
                if (properties_get_integer(decoder->status->info.properties,
                                           XA_MPEG_CODEC_PROPERTY_STREAM_MODE,
                                           &mode) == XA_SUCCESS) {
                    fprintf(stderr, ", %s", ModeStrings[mode]);
                }
                fprintf(stderr, ", %ld kbps, %ld hz\n",
                        decoder->status->info.bitrate,
                        decoder->status->info.frequency);
            } else {
                fprintf(stderr, "XAUDIO: stream type = %s, %ld kbps, %ld hz\n",
                        decoder->status->info.mime_type,
                        decoder->status->info.bitrate,
                        decoder->status->info.frequency);
            }
        } else {
            /* unknown type */
            fprintf(stderr, "XAUDIO: stream type = unknown");
        }

        /* print properties */
        {
            XA_PropertyList list;
            if (properties_get_list(decoder->status->info.properties, &list) == 
                XA_SUCCESS &&
                list.nb_properties > 0) {
                unsigned int i;
                fprintf(stderr, "XAUDIO: stream properties:\n");
                for (i=0; i<list.nb_properties; i++) {
                    switch (list.properties[i].type) {
                      case XA_PROPERTY_TYPE_STRING:
                        fprintf(stderr, "    %s = [%s]\n", 
                                list.properties[i].name,
                                list.properties[i].value.string);
                        break;
                      case XA_PROPERTY_TYPE_INTEGER:
                        fprintf(stderr, "    %s = %ld\n",
                                list.properties[i].name,
                                list.properties[i].value.integer);
                        break;
                    }
                }
            }
        }
    }

    if (decoder->status->info.duration != duration) {
        duration = decoder->status->info.duration;
        fprintf(stderr, "XAUDIO: input duration = ");
        if (duration) {
            fprintf(stderr, "%ld seconds\n", duration/1000);
        } else {
            fprintf(stderr, "unknown\n");
        }
    }
}

/*----------------------------------------------------------------------
|       main
+---------------------------------------------------------------------*/
int 
main(int argc, char **argv)
{
    XA_DecoderInfo *decoder;
    char          **urls;
    char           *stdin_input[] = {"-", 0};
    char           *current;
    int             status;

    /* instanciate a decoder */
    decoder = cmdline_init();

    /* read options */
    urls = cmdline_parse_argv(decoder, argv+1);

    /* are we playing from stdin ? */
    if (!urls[0]) {
        urls = stdin_input;
        fprintf(stderr, "XAUDIO: playing from stdin\n");
    }

    if (Options.output.port == 0) {
        Options.output.port = 
            XA_DECODER_CONTROL_OUTPUT_SPEAKER | 
            XA_DECODER_CONTROL_OUTPUT_LINE;
    };

    /* open output */
    decoder_output_new(decoder, 
                       Options.output.name,    
                       XA_DECODER_OUTPUT_AUTOSELECT);
    status = decoder_output_open(decoder);
    if (status != XA_SUCCESS) {
        fprintf(stderr, 
                "XAUDIO: cannot instanciate  output (%s)\n",
                xaudio_error_string(status));
        exit(1);
    }

    {
        XA_OutputControl control;
        unsigned long    to_set = 0;

        control.ports = Options.output.port;
        to_set |= XA_DECODER_CONTROL_PORTS;

        if (Options.output.volume != -1) {
            control.pcm_level = Options.output.volume;
            to_set |= XA_DECODER_CONTROL_PCM_LEVEL;
        }

        decoder_output_set_control(decoder, &control, to_set);
    }

    while ((current = *urls++)) {
        decoder_input_new(decoder, current, XA_DECODER_INPUT_AUTOSELECT);
        status = decoder_input_open(decoder);
        if (status == XA_SUCCESS) {
            cmdline_monitor_stream_info(decoder);
            do {
                status = decoder_play(decoder);
                if (status == XA_SUCCESS) cmdline_monitor_stream_info(decoder);
            } while (status == XA_SUCCESS ||
                     status == XA_ERROR_INVALID_FRAME ||
                     status == XA_ERROR_TIMEOUT);

            decoder_output_set_control(decoder, NULL, 
                                       XA_DECODER_CONTROL_DRAIN);
            decoder_input_close(decoder);
        } else {
            fprintf(stderr, 
                    "XAUDIO: cannot open input (%s)\n",
                    xaudio_error_string(status));
        }
    }

    decoder_delete(decoder);
    return 0;
}