mpeg2dec.c

在linux下开发音频播放器的源代码

/* mpeg2dec.c, main(), initialization, option processing                    */

/* Copyright (C) 1994, MPEG Software Simulation Group. All Rights Reserved. */

/*
 * Disclaimer of Warranty
 *
 * These software programs are available to the user without any license fee or
 * royalty on an "as is" basis.  The MPEG Software Simulation Group disclaims
 * any and all warranties, whether express, implied, or statuary, including any
 * implied warranties or merchantability or of fitness for a particular
 * purpose.  In no event shall the copyright-holder be liable for any
 * incidental, punitive, or consequential damages of any kind whatsoever
 * arising from the use of these programs.
 *
 * This disclaimer of warranty extends to the user of these programs and user's
 * customers, employees, agents, transferees, successors, and assigns.
 *
 * The MPEG Software Simulation Group does not represent or warrant that the
 * programs furnished hereunder are free of infringement of any third-party
 * patents.
 *
 * Commercial implementations of MPEG-1 and MPEG-2 video, including shareware,
 * are subject to royalty fees to patent holders.  Many of these patents are
 * general enough such that they are unavoidable regardless of implementation
 * design.
 *
 */

// MS Windows includes
#include <windows.h>
#include <commdlg.h>
#include <assert.h>
#include <io.h>
#include "gui.h"
#define APPNAME            "Mpeg2Play"    /* The name of this application */
#define BASEWINDOWTITLE    "MPEG2 Software Simulation" /* The title bar text */
#define MAXFILENAME        256           /* maximum length of file pathname      */
#define MAXCUSTFILTER      40            /* maximum size of custom filter buffer */
// display related variables
#define		START	    0
#define		READY	    1
#define   PLAYING   2
#define   PAUSED    3
#define   FINISH    4
#define		STOP	    5


#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <fcntl.h>

#define GLOBAL
#include "config.h"
#include "global.h"

// MS Windows related variables
LRESULT CALLBACK WndProc(HWND   hWnd,       // window handle
                         UINT   message,    // type of message
                         WPARAM uParam,     // additional information
                         LPARAM lParam);    // additional information
static HINSTANCE   hInst;          // current instance
static HWND        ghWnd   =NULL;  // handle to main window
static char       *image   =NULL;
static char        szFileName[MAXFILENAME]="";
static unsigned short gusState = START;
static int         nDitherType;
static HDC         hDC;
static HPALETTE    hpal,
                   hPalPrev=NULL;
static PBITMAPINFO pbmi    =NULL;

static void play_movie(void);
extern int         __argc;
extern char      **__argv;

/* private prototypes */
static void initdecoder _ANSI_ARGS_((void));
static void options _ANSI_ARGS_((int *argcp, char **argvp[]));
static int getval _ANSI_ARGS_((char *argv[]));


// MS Windows related functions
/////////////////////////////////////////////////////////////////////////////
/*
 *********************************************************************************
 *
 * WinMain:
 *
 *********************************************************************************
*/

//
// yield function to simulate multitasking on MS Windows
//
static void myYield(void)
{
    MSG		msg;

    if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
    {
	    TranslateMessage(&msg);// Translates virtual key codes
	    DispatchMessage(&msg); // Dispatches message to window
	}
}

//
// initializations
//
static BOOL InitApplication(HINSTANCE hInstance)
{
   WNDCLASS  wc;

   // Fill in window class structure with parameters that describe the
   // main window.

   wc.style         = CS_OWNDC | CS_HREDRAW | CS_VREDRAW;// Class style(s).
   wc.lpfnWndProc   = (WNDPROC)WndProc;           // Window Procedure
   wc.cbClsExtra    = 0;                          // No per-class extra data.
   wc.cbWndExtra    = 0;                          // No per-window extra data.
   wc.hInstance     = hInstance;                  // Owner of this class
   wc.hIcon         = LoadIcon (hInstance, APPNAME); // Icon name from .RC
   wc.hCursor       = LoadCursor(NULL, IDC_ARROW);// Cursor
   wc.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);   // Default color
   wc.lpszMenuName  = APPNAME;                    // Menu name from .RC
   wc.lpszClassName = APPNAME;                    // Name to register as

   // Register the window class and return success/failure code.
   return (RegisterClass(&wc));
}

static BOOL InitInstance(HINSTANCE hInstance,int       nCmdShow)
{

    // Save the instance handle in static variable, which will be used in
    // many subsequence calls from this application to Windows.

    hInst = hInstance; // Store instance handle in our global variable

    // Create a main window for this application instance.

    ghWnd = CreateWindow(APPNAME,            // See RegisterClass() call.
                         BASEWINDOWTITLE,    // Text for window title bar.
                         WS_OVERLAPPEDWINDOW &
                         ~WS_THICKFRAME &
                         ~WS_MAXIMIZEBOX,    // Window style.
                         CW_USEDEFAULT,
                         0,
                         CW_USEDEFAULT,
                         0,                  // Use default positioning
                         NULL,               // Overlapped windows have no parent.
                         NULL,               // Use the window class menu.
                         hInstance,          // This instance owns this window.
                         NULL                // We don't use any data in our WM_CREATE
        );

    // If window could not be created, return "failure"
    if (!ghWnd)
       return (FALSE);

    // Make the window visible; update its client area; and return "success"
    ShowWindow(ghWnd, nCmdShow); // Show the window
    UpdateWindow(ghWnd);         // Sends WM_PAINT message

    return (TRUE);              // We succeeded...

}

//
// prompts the user for the efile name
//
static BOOL AskUserFileName(char szFileName[],char szFileTitle[])
{
   /* new variables for common dialogs */
   static char         szFilterSpec[]="MPEG2 Video Files\0*.M2V\0MPEG1 Video Files\0*.M1V\0MPEG Files\0*.MPG\0All Files (*.*)\0*.*\0";
   static char         szInitialDirectory[MAXFILENAME]="";
          OPENFILENAME ofn;

   memset(&ofn,0,sizeof(ofn));

   /* fill in non-variant fields of OPENFILENAME struct. */
   ofn.lStructSize       = sizeof(OPENFILENAME);
   ofn.hwndOwner         = ghWnd;
   ofn.lpstrFilter       = szFilterSpec;
   ofn.lpstrCustomFilter = NULL;
   ofn.nMaxCustFilter    = 0;
   ofn.nFilterIndex      = 0;
   ofn.lpstrFile         = szFileName;
   ofn.nMaxFile          = MAXFILENAME;
   if (!szInitialDirectory[0])
      GetModuleFileName(hInst, szInitialDirectory, MAXFILENAME);

   // strip the file name
   *(LPSTR)strrchr(szInitialDirectory,'\\')=0;

   ofn.lpstrInitialDir     = szInitialDirectory;
   ofn.lpstrFileTitle      = szFileTitle;
   ofn.nMaxFileTitle       = MAXFILENAME;
   ofn.lpstrTitle          = NULL;
   ofn.lpstrDefExt         = "MPG";
   ofn.Flags               = 0;

   if (!GetOpenFileName ((LPOPENFILENAME)&ofn))
      return FALSE;

   // save the current directory
   lstrcpy(szInitialDirectory,szFileName);
   return TRUE;
}


/*********************************************************************************
 *
 * About box
 *
*********************************************************************************
*/

BOOL CALLBACK About(HWND   hDlg,         // window handle of the dialog box
                    UINT   message,      // type of message
                    WPARAM uParam,       // message-specific information
                    LPARAM lParam)
{
   switch (message)
   {
      case WM_COMMAND:                     // message: received a command
         if (LOWORD(uParam) == IDOK || LOWORD(uParam) == IDCANCEL)
         {
            EndDialog(hDlg, TRUE);        // Exit the dialog
            return (TRUE);
         }
         break;
   }
   return (FALSE); // Didn't process the message

   lParam; // This will prevent 'unused formal parameter' warnings
}

//
// Main window procedure
//
LRESULT CALLBACK WndProc(HWND   hWnd,       // window handle
                         UINT   message,    // type of message
                         WPARAM uParam,     // additional information
                         LPARAM lParam)     // additional information
{
   switch (message)
   {
      case WM_CLOSE:
	    gusState = STOP;
	    myYield();
      return (DefWindowProc(hWnd, message, uParam, lParam));
	    break;


      case WM_DESTROY:  // message: window being destroyed
	    gusState = STOP;
	    myYield();
      PostQuitMessage(0);
      break;

      case WM_COMMAND:  // message: command from application menu
      {
        int wmId, wmEvent;

        wmId    = LOWORD(uParam);
        wmEvent = HIWORD(uParam);

        switch (wmId)
        {
           case IDM_OPEN:
           {
              char szWindowTitle[80];
              char szFileTitle[MAXFILENAME];

               // if something was playing, give a chance to stop.
              if (gusState > READY)
              {
                 gusState = STOP;
                 myYield();
              }

              EnableMenuItem(GetMenu(hWnd), IDM_PLAY, MF_GRAYED | MF_DISABLED);

              szFileName[0]=0;
              if (!AskUserFileName (szFileName,szFileTitle))
                 return FALSE;

              lstrcpy(szWindowTitle, BASEWINDOWTITLE);
              lstrcat(szWindowTitle, " - ");
              lstrcat(szWindowTitle, szFileTitle);
              SetWindowText(hWnd, szFileTitle);

              // enable play menu
              EnableMenuItem(GetMenu(hWnd), IDM_PLAY, MF_ENABLED);

              gusState = READY;
              break;
           }

           case IDM_PLAY:
              // disable play menu while playing
              EnableMenuItem(GetMenu(hWnd), IDM_STOP, MF_ENABLED);
              EnableMenuItem(GetMenu(hWnd), IDM_PLAY, MF_GRAYED | MF_DISABLED);

              // play the movie. It returns after the playing ended
              play_movie();

              // disable stop menu
              EnableMenuItem(GetMenu(hWnd), IDM_STOP, MF_GRAYED | MF_DISABLED);
              EnableMenuItem(GetMenu(hWnd), IDM_PLAY, MF_ENABLED);
              SetWindowText(hWnd, BASEWINDOWTITLE);
              break;

           case IDM_STOP:
              gusState=STOP;
              // force a task switch to allow the decoder to see the stop command
              myYield();
              break;

           case IDM_EXIT:
              SendMessage(hWnd, WM_CLOSE, 0, 0l);
              break;

           case IDM_ABOUT:
           {
              FARPROC lpProcAbout;  // pointer to the "About" function

              lpProcAbout = MakeProcInstance((FARPROC)About, hInst);
              DialogBox(hInst,                 // current instance
                        "AboutBox",            // dlg resource to use
                        hWnd,                  // parent handle
                        (DLGPROC)lpProcAbout); // About() instance address

              FreeProcInstance(lpProcAbout);
              break;
           }

           case IDM_YUV_FILE:
           case IDM_Y_U_V_FILE:
           case IDM_TGA_FILE:
           case IDM_DISPLAY8:
           case IDM_DISPLAY24:
              // reset the display.
              // It will be reinitialized the first time it will be called
              switch (outtype)
              {
                 case T_YUV:
                   CheckMenuItem(GetMenu(hWnd), IDM_YUV_FILE, MF_UNCHECKED);
                   break;

                 case T_SIF:
                   CheckMenuItem(GetMenu(hWnd), IDM_Y_U_V_FILE, MF_UNCHECKED);
                   break;

                 case T_TGA:
                   CheckMenuItem(GetMenu(hWnd), IDM_TGA_FILE, MF_UNCHECKED);
                   break;

#ifdef DISPLAY
                 case T_X11:
                   if (nDitherType==8)
                      CheckMenuItem(GetMenu(hWnd), IDM_DISPLAY8, MF_UNCHECKED);
                   else
                      CheckMenuItem(GetMenu(hWnd), IDM_DISPLAY24, MF_UNCHECKED);
                   break;
#endif
              }
              switch (wmId)
              {
                 case IDM_YUV_FILE:
                    CheckMenuItem(GetMenu(hWnd), IDM_YUV_FILE, MF_CHECKED);
                    outtype=T_YUV;
                    break;

                 case IDM_Y_U_V_FILE:
                    CheckMenuItem(GetMenu(hWnd), IDM_Y_U_V_FILE, MF_CHECKED);
                    outtype=T_SIF;
                    break;

                 case IDM_TGA_FILE:
                    CheckMenuItem(GetMenu(hWnd), IDM_TGA_FILE, MF_CHECKED);
                    outtype=T_TGA;
                    break;

#ifdef DISPLAY
                 case IDM_DISPLAY8:
                    CheckMenuItem(GetMenu(hWnd), IDM_DISPLAY8, MF_CHECKED);
                    outtype=T_X11;
                    nDitherType=8;
                    break;

                 case IDM_DISPLAY24:
                    CheckMenuItem(GetMenu(hWnd), IDM_DISPLAY24, MF_CHECKED);
                    outtype=T_X11;
                    nDitherType=24;
                    break;
#endif
              }
        }
        break;
      }

      default:          // Passes it on if unproccessed
        return (DefWindowProc(hWnd, message, uParam, lParam));
   }
   return (0);
}

//
// program entry point
//
int APIENTRY WinMain(HINSTANCE   hInstance,
                     HINSTANCE   hPrevInstance,
                     LPSTR       lpCmdLine,
                     int         nCmdShow)
{
    MSG msg;

    if (!hPrevInstance)
       // Other instances of app running?
        if (!InitApplication(hInstance))
           // Initialize shared things
           return (FALSE);     // Exits if unable to initialize

    /* Perform initializations that apply to a specific instance */
    if (!InitInstance(hInstance, nCmdShow))
       return (FALSE);