Пример #1
0
struct timidity_file *open_with_mem(char *mem, int32 memlen, int noise_mode)
{
    URL url;
    struct timidity_file *tf;

    errno = 0;
    if((url = url_mem_open(mem, memlen, 0)) == NULL)
    {
	if(noise_mode >= 2)
	    ctl->cmsg(CMSG_ERROR, VERB_NORMAL, "Can't open.");
	return NULL;
    }
    tf = (struct timidity_file *)safe_malloc(sizeof(struct timidity_file));
    tf->url = url;
    tf->tmpname = NULL;
    return tf;
}
Пример #2
0
/* return 0 (successful or not convert)
          -1 (error and lost tf->url) */
int smfconv_w32(struct timidity_file *tf, char *fn)
{
    URL url;
    int ret;
    struct midi_file_info *infop;

    /* rcpcv.dll convertion stage */
rcpcv_dll_stage:
    if(exist_rcpcv_dll())
    {

        ret = is_midifile_filename(fn);
        if(ret == IS_RCP_FILE || ret == IS_R36_FILE || ret == IS_G18_FILE || ret == IS_G36_FILE)
        {
            if(!IS_URL_SEEK_SAFE(tf->url))
                tf->url = url_cache_open(tf->url, 1);
            ret = is_midifile_url(tf->url);
            url_rewind(tf->url);
            if(ret == IS_RCP_FILE || ret == IS_R36_FILE || ret == IS_G18_FILE || ret == IS_G36_FILE)
            {
                ctl->cmsg(CMSG_INFO,VERB_NORMAL,"Try to Convert RCP,R36,G18,G36 to SMF by RCPCV.DLL (c)1997 Fumy.");
                url = rcpcv_convert(tf->url,ret);
                if(url == NULL) {
                    /* url_arc or url_cash is buggy ? */
                    /*
                    url_rewind(tf->url);
                    url_cache_disable(tf->url);
                    ctl->cmsg(CMSG_INFO,VERB_NORMAL,"Convert Failed.");
                    goto end_of_rcpcv_dll_stage;
                    */

                    char *buffer;
                    int len;
                    URL new_url;

                    url_rewind(tf->url);
                    if((buffer = (char *)url2mem(tf->url,&len))==NULL) {
                        ctl->cmsg(CMSG_INFO,VERB_NORMAL,"Convert Failed.");
                        goto end_of_rcpcv_dll_stage;
                    }
                    if((new_url=url_mem_open(buffer,len,1))==NULL) {
                        ctl->cmsg(CMSG_INFO,VERB_NORMAL,"Convert Failed and Memory Allocate Error.");
                        url_cache_disable(tf->url);
                        return -1;
                    }
                    url_close(tf->url);
                    tf->url = new_url;
                    ctl->cmsg(CMSG_INFO,VERB_NORMAL,"Convert Failed.");
                    goto end_of_rcpcv_dll_stage;
                }
                url_cache_disable(tf->url);
                tf->url = url;
                ctl->cmsg(CMSG_INFO,VERB_NORMAL,"Convert Completed.");

                /* Store the midi file type information */
                infop = get_midi_file_info(fn, 1);
                infop->file_type = ret;
            } else
                url_cache_disable(tf->url);
        }

    }
    /* end of rcpcv.dll convertion stage */
end_of_rcpcv_dll_stage:

    /* smfk32.dll convertion stage */
smfk32_dll_stage:

    /* not exist */

    /* end of smfk32.dll convertion stage */
end_of_smfk32_dll_stage:

last_stage:
    return 0;
}
Пример #3
0
/* return new URL
          NULL (error) */
static URL rcpcv_convert(URL url,int type)
{
    char *buffer;
    HINSTANCE hRcpcv;
    UINT fuErrorMode;
    long len;
    HRCPCV CALLBACK h;
    int rcpcv_type;
    URL new_url;

    HRCPCV (CALLBACK *lpRcpcvConvertFileFromBuffer)(LPCSTR,UINT,UINT,UINT,DWORD,UINT,DWORD);
    void (CALLBACK *lpRcpcvDeleteObject)(HRCPCV);
    LPCSTR (CALLBACK *lpRcpcvGetSMF)(HRCPCV);
    int (CALLBACK *lpRcpcvGetSMFLength)(HRCPCV);

    /* type */
    switch(type) {
    case IS_RCP_FILE:
    case IS_R36_FILE:
        rcpcv_type = RCPCV_FORMATTYPE_RCM25F;
        break;
    case IS_G18_FILE:
    case IS_G36_FILE:
        rcpcv_type = RCPCV_FORMATTYPE_RCM25G;
        break;
    default:
        return NULL;
    }

    /* rcpcv 1*/
    fuErrorMode = SetErrorMode(SEM_NOOPENFILEERRORBOX);
    hRcpcv = LoadLibrary("rcpcv.dll");
    SetErrorMode(fuErrorMode);
    if(hRcpcv==NULL)
        return NULL;

    /* url -> buffer */
    buffer = (char *)url2mem(url,&len);

    /* rcpcv 2*/
    lpRcpcvConvertFileFromBuffer = GetProcAddress(hRcpcv,"rcpcvConvertFileFromBuffer");
    lpRcpcvDeleteObject = GetProcAddress(hRcpcv,"rcpcvDeleteObject");
    lpRcpcvGetSMF = GetProcAddress(hRcpcv,"rcpcvGetSMF");
    lpRcpcvGetSMFLength = GetProcAddress(hRcpcv,"rcpcvGetSMFLength");

    h = (*lpRcpcvConvertFileFromBuffer)((LPCSTR)buffer,(UINT)len,(UINT)rcpcv_type,RCPCV_CALLBACK_NULL,NULL, 0, 0);
    if (h==NULL) {
        free(buffer);
        FreeLibrary(hRcpcv);
        return NULL;
    }
    len = (*lpRcpcvGetSMFLength)(h);
    if((buffer = (char *)safe_realloc(buffer,len + 10))==NULL) {
        FreeLibrary(hRcpcv);
        return NULL;
    }
    memcpy(buffer,(*lpRcpcvGetSMF)(h),len);
    (*lpRcpcvDeleteObject)(h);
    FreeLibrary(hRcpcv);

    /* url_mem_open */
    if((new_url=url_mem_open(buffer,len,1))==NULL) {
        return NULL;
    }

    url_close(url);
    return new_url;
}