main.cpp

FreeAMP(MP3播放)程序源代码-用来研究MP3解码

            char path[MAX_PATH];
            char url[MAX_PATH + 7];
            uint32 length = sizeof(url);
            int offset = 0;

            KillTimer(hwnd, 1);

            bool playNow = false;

            context->prefs->GetPrefBoolean(kPlayImmediatelyPref, &playNow);
            
            // If a single theme or rpm file gets passed, don't affect 
            // the play queue
            if (strcasecmp("fat", array + strlen(array) - 3) == 0 ||
                strcasecmp("rmp", array + strlen(array) - 3) == 0)
                playNow = false;

            if(playNow)
            {
                if(replaceCurrentQueue)
                {
                    context->target->AcceptEvent(new Event(CMD_Stop));
                    context->plm->RemoveAll();

                    replaceCurrentQueue = false;
                }
            }

            for(int32 i = 0; i < count; i++)
            {
                strcpy(path, array + offset);
                offset += strlen(path) + 1;

                // is this a URL we know how to handle
                if( !strncasecmp(path, "http://", 7) ||
                    !strncasecmp(path, "rtp://", 6))
                {
                    context->plm->AddItem(path);

                    if(playNow)
                    {
                        SetTimer(hwnd, 1, 1000, NULL);
                    }

                    continue;
                }

                HANDLE handle;
                WIN32_FIND_DATA data;

                handle = FindFirstFile(path, &data);

                if(handle != INVALID_HANDLE_VALUE)
                {
                    char* cp = NULL;

                    cp = strrchr(path, '\\');

                    if(cp)
                    {
                        strcpy(cp + 1, data.cFileName);
                    }

                    FindClose(handle);
                }

                FilePathToURL(path, url, &length);

                // who needs to get this, plm or dlm?
                bool giveToDLM = false;
                bool giveToTheme = false;
                char* extension = NULL;
                PlaylistManager* plm = context->plm;
                DownloadManager* dlm = context->downloadManager;

                extension = strrchr(url, '.');
                if(extension)
                {
                    DownloadFormatInfo dlfi;
                    uint32 i = 0;

                    extension++;

                    while(IsntError(dlm->GetSupportedDownloadFormats(&dlfi, i++)))
                    {
                        if(!strcasecmp(extension, dlfi.GetExtension()))
                        {
                            giveToDLM = true;
                            break;
                        }
                    }
                    if (strcasecmp(extension, themeExtension) == 0)
                        giveToTheme = true; 
                }

                if(giveToDLM)
                    dlm->ReadDownloadFile(url);
                else if(giveToTheme)
                    context->player->AddTheme(url);
                else
                    plm->AddItem(url);

                if(playNow)
                {
                    SetTimer(hwnd, 1, 1000, NULL);
                }
            }
            
            break;
        }
        
        case WM_DISPLAYCHANGE:
        {
            context->target->AcceptEvent(new Event(INFO_PrefsChanged));
            break;
        }
        default:
            result = DefWindowProc(hwnd, msg, wParam, lParam);
            break;

    }

    return result;
}


void CreateHiddenWindow(void* arg)
{
    FAContext* context = (FAContext*)arg;
    WNDCLASS wc;
    MSG      msg;
    HWND     hwnd;

    memset(&wc, 0x00, sizeof(WNDCLASS));

    wc.lpfnWndProc = HiddenWndProc;
    wc.hInstance = g_hinst;
    wc.lpszClassName = kHiddenWindow;

    RegisterClass(&wc);
         
    hwnd = CreateWindow(kHiddenWindow, 
                        kHiddenWindow,
                        WS_POPUP, 
                        0, 
                        0, 
                        100, 
                        100,
                        NULL, 
                        NULL, 
                        g_hinst, 
                        context);

    if(hwnd)
    {
        while(GetMessage(&msg, NULL, 0, 0))
        {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
    }
}

const char* kFileTypes[][5] = {
    {".mp1", "MPEGAudioFile", "audio/x-mpeg", "MPEG Audio File", "13"},
    {".mp2", "MPEGAudioFile", "audio/x-mpeg", "MPEG Audio File", "13"},
    {".mp3", "MPEGAudioFile", "audio/x-mpeg", "MPEG Audio File", "13"},
    {".m3u", "M3UPlaylistFile", "audio/x-mpegurl", "M3U Playlist File", "16"},
    {".pls", "PLSPlaylistFile", "audio/x-scpls", "PLS Playlist File", "17"},
    {".rmp", "RealMusicPackage", "application/vnd.rn-rn_music_package", "Real Music Package", "4"},
    {".fat", "FreeAmpTheme", "application/x-freeamp-theme", "FreeAmp Theme File", "19"},
    {NULL, NULL}
};

const char* kMimeTypes[] = {
    "audio/x-mpeg",
    "audio/x-mp3",
    "audio/x-mpegurl",
    "audio/x-scpls",
    "audio/mpeg",
    "audio/mp3",
    "audio/mpegurl",
    "audio/scpls",
    "application/vnd.rn-rn_music_package",
    "application/x-freeamp-theme",
    NULL
};

const char* kOpenCommand = "\\shell\\open\\command";
const char* kNotifyStolen = "Music files normally associated with "the_BRANDING "\r\n"
                            "have been associated with another application.\r\n"
                            "Do you want to reclaim these music files?";

void ReclaimFileTypes(const char* path, bool askBeforeReclaiming)
{
    LONG    result; 
    DWORD   index;
    HKEY    typeKey;
    HKEY    appKey;
    DWORD   type;
    char    buf[MAX_PATH];
    char    openString[MAX_PATH + 8];
    DWORD   len = sizeof(buf);
    bool    permission = false;

    //"C:\Program Files\FreeAmp\freeamp.exe" "%1"

    wsprintf(openString, "\"%s\" \"%%1\"", path);

    if(!askBeforeReclaiming)
        permission = true;

    // reclaim the windows filetypes
    for(index = 0; ; index++)
    {
        if(kFileTypes[index][0] == NULL)
            break;

        result = RegOpenKeyEx(HKEY_CLASSES_ROOT,
							  kFileTypes[index][0],
							  0, 
                              KEY_WRITE|KEY_READ,
                              &typeKey);

        if(result == ERROR_SUCCESS)
	    {
            len = sizeof(buf);
		    result = RegQueryValueEx(typeKey,
                                     NULL, 
                                     NULL, 
                                     &type, 
                                     (LPBYTE)buf, 
                                     &len);

            if(result == ERROR_SUCCESS)
            {
                //MessageBox(NULL, buf, "value", MB_OK);
                if(stricmp(buf, kFileTypes[index][1]))
                {
                    if(!permission)
                    {
                        int ret;
                        ret = MessageBox(NULL, 
                                   kNotifyStolen,
                                   "Reclaim File Types?", 
                                   MB_YESNO|MB_ICONQUESTION);

                        if(ret == IDYES)
                            permission = true;
                        else
                        {
                            RegCloseKey(typeKey);
                            return;
                        }
                    }

                    RegSetValueEx(typeKey,
                                  NULL, 
                                  NULL, 
                                  REG_SZ, 
                                  (LPBYTE)kFileTypes[index][1], 
                                  strlen(kFileTypes[index][1]) + 1);
                }
            }

            RegCloseKey(typeKey);
        }
        else // create it
        {
            RegCreateKey(HKEY_CLASSES_ROOT,
                         kFileTypes[index][0],
                         &typeKey);

            RegSetValueEx(typeKey,
                          NULL, 
                          NULL, 
                          REG_SZ, 
                          (LPBYTE)kFileTypes[index][1], 
                          strlen(kFileTypes[index][1]) + 1);

            RegSetValueEx(typeKey,
                          "Content Type", 
                          NULL, 
                          REG_SZ, 
                          (LPBYTE)kFileTypes[index][2], 
                          strlen(kFileTypes[index][2]) + 1);

            RegCloseKey(typeKey);
        }

        wsprintf(buf, "%s%s", kFileTypes[index][1], kOpenCommand);

        result = RegOpenKeyEx(	HKEY_CLASSES_ROOT,
							    buf,
							    0, 
							    KEY_WRITE|KEY_READ,
							    &appKey);

        if(result == ERROR_SUCCESS)
	    {
            len = sizeof(buf);
		    result = RegQueryValueEx(appKey,
                                     NULL, 
                                     NULL, 
                                     &type, 
                                     (LPBYTE)buf, 
                                     &len);

            if(result == ERROR_SUCCESS)
            {
                //MessageBox(NULL, buf, "value", MB_OK);
                if(stricmp(buf, openString))
                {
                    if(!permission)
                    {
                        int ret;
                        ret = MessageBox(NULL, 
                                   kNotifyStolen,
                                   "Reclaim File Types?", 
                                   MB_YESNO|MB_ICONQUESTION);

                        if(ret == IDYES)
                            permission = true;
                        else
                        {
                            RegCloseKey(appKey);
                            return;
                        }
                    }

                    RegSetValueEx(appKey,
                                  NULL, 
                                  NULL, 
                                  REG_SZ, 
                                  (LPBYTE)openString, 
                                  strlen(openString) + 1);
                }
            }

            RegCloseKey(appKey);
        }
        else // create it
        {
            HKEY iconKey;
            char iconPath[MAX_PATH];

            RegCreateKey(HKEY_CLASSES_ROOT,
                         kFileTypes[index][1],
                         &appKey);

            RegSetValueEx(appKey,
                          NULL, 
                          NULL, 
                          REG_SZ, 
                          (LPBYTE)kFileTypes[index][3], 
                          strlen(kFileTypes[index][3]) + 1);
            
            
            sprintf(iconPath, "%s,%s", path,  kFileTypes[index][4]);

            RegCreateKey(appKey,
                         "DefaultIcon",
                         &iconKey);

            RegSetValueEx(iconKey,
                          NULL, 
                          NULL, 
                          REG_SZ, 
                          (LPBYTE)iconPath, 
                          strlen(iconPath) + 1);

            
            RegCloseKey(iconKey);
            RegCloseKey(appKey);

            RegCreateKey(HKEY_CLASSES_ROOT,
                         buf,
                         &appKey);

            RegSetValueEx(appKey,
                          NULL, 
                          NULL, 
                          REG_SZ, 
                          (LPBYTE)openString, 
                          strlen(openString) + 1);

            
            RegCloseKey(appKey);
        }
    }


    // reclaim netscape filetypes

    result = RegOpenKeyEx(HKEY_CURRENT_USER,
                          "Software\\Netscape\\Netscape Navigator\\Viewers",
                          0, 
                          KEY_WRITE|KEY_READ,
                          &appKey);

    if(result == ERROR_SUCCESS)
    {
        for(index = 0; ; index++)
        {
            if(kMimeTypes[index] == NULL)
                break;
        
            len = sizeof(buf);
		    result = RegQueryValueEx(appKey,
                                     kMimeTypes[index], 
                                     NULL, 
                                     &type, 
                                     (LPBYTE)buf, 
                                     &len);

            if(result == ERROR_SUCCESS)
            {
                //MessageBox(NULL, buf, "value", MB_OK);
                if(stricmp(buf, path))
                {
                    if(!permission)
                    {
                        int ret;
                        ret = MessageBox(NULL, 
                                   kNotifyStolen,
                                   "Reclaim File Types?", 
                                   MB_YESNO|MB_ICONQUESTION);

                        if(ret == IDYES)
                            permission = true;
                        else
                        {
                            RegCloseKey(appKey);
                            return;
                        }
                    }

                    RegSetValueEx(appKey,
                                  kMimeTypes[index], 
                                  NULL, 
                                  REG_SZ, 
                                  (LPBYTE)path, 
                                  strlen(path) + 1);
                }
            }
        }

        RegCloseKey(appKey);
    }
}

bool IsWinNT(void)
{
   OSVERSIONINFO osv;
   osv.dwOSVersionInfoSize=sizeof(osv);
   GetVersionEx(&osv);
   return osv.dwPlatformId==VER_PLATFORM_WIN32_NT;
}

bool IsMultiProcessor(void)
{
   SYSTEM_INFO sInfo;
   
   GetSystemInfo(&sInfo);
   return sInfo.dwNumberOfProcessors > 1;
}