Книга: Графика для Windows средствами DirectDraw

Программа AviPlay

Программа AviPlay

Пора браться за программирование. Программу AviPlay, как и все остальные программы, рассматриваемые в этой книге, можно найти на CD-ROM.

Программа AviPlay использует Video For Windows для открытия и воспроизведения AVI-файлов на поверхностях DirectDraw. Она позволяет выбрать любой AVI-файл и задать видеорежим для воспроизведения ролика. Диалоговое окно для выбора файла изображено на рис. 8.1.

Рис. 8.1. Диалоговое окно для выбора AVI-файла в программе AviPlay

Если вы еще не успели опробовать программу AviPlay и не обнаружили этого сами, я хочу указать на несколько вещей, которые эта программа не умеет делать. Например, она не воспроизводит аудиопотоки из выбранного AVI-файла, а лишь извлекает и воспроизводит графическую часть файла.

Кроме того, программа не пытается управлять частотой вывода кадров; все кадры извлекаются и воспроизводятся с максимальной скоростью. В каждом AVI-файле присутствуют хронометрические данные, которые используются всеми полноценными программами для воспроизведения AVI-файлов.

Еще одна полезная возможность, которая бы пригодилась в программе AviPlay, — поддержка 16- и 24-битных видеорежимов. В представленном варианте всегда применяются 8-битные режимы независимо от глубины пикселей воспроизводимого ролика.

Большинство возможностей программы AviPlay обеспечивается классом AviPlayWin, который наследует поддержку DirectDraw от класса DirectDrawWin. В отличие от других программ этой книги класс AviPlayWin использует диалоговое окно для выбора файла. Вместо того чтобы создавать поверхности при запуске, программа AviPlay (как и программа BmpView из главы 5) ожидает, пока пользователь выберет файл. Затем программа создает поверхности и настраивает их в соответствии с содержимым выбранного файла. Определение класса AviPlayWin приведено в листинге 8.1.

Листинг 8.1. Класс AviPlayWin

class AviPlayWin : public DirectDrawWin {
public:
 AviPlayWin();
protected:
 //{{AFX_MSG(AviPlayWin)
 afx_msg void OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags);
 afx_msg void OnRButtonDown(UINT nFlags, CPoint point);
 afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct);
 afx_msg void OnDestroy();
 //}}AFX_MSG
 DECLARE_MESSAGE_MAP()
private:
 int SelectInitialDisplayMode();
 BOOL CreateCustomSurfaces() {
  return TRUE;
 }
 void DrawScene();
 void RestoreSurfaces();
 void GetSystemPalette();
 void ShowDialog();
 BOOL LoadAvi();
 BOOL CreateAviSurface();
 BOOL UpdateAviSurface();
 BOOL InstallPalette();
private:
 AviDialog* avidialog;
 CString fullfilename;
 CString filename;
 CString pathname;
 CRect displayrect;
 LPDIRECTDRAWSURFACE avisurf;
 CRect avirect;
 int x,y;
 DisplayModeArray displaymode;
 LPDIRECTDRAWPALETTE syspal;
 LPDIRECTDRAWPALETTE avipal;
 PAVISTREAM avistream;
 AVISTREAMINFO streaminfo;
 HIC decomp;
 long fmtlen, buflen;
 long startframe, endframe;
 long curframe;
 LPBITMAPINFOHEADER srcfmt;
 LPBITMAPINFOHEADER dstfmt;
 BYTE* rawdata;
 BYTE* finaldata;
};

Сначала мы объявляем конструктор класса AviPlayWin, предназначенный только для инициализации переменных класса.

В классе определены четыре обработчика сообщений: OnKeyDown(), OnRButtonDown(), OnCreate() и OnDestroy(). Функция OnKeyDown() следит за нажатием клавиш Escape и пробела во время воспроизведения, прерывает ролик и отображает диалоговое окно для выбора AVI-файла (мы могли воспользоваться DirectInput, но программа AviPlay не стоит подобных хлопот). Функция OnRButtonDown() тоже вызывает диалоговое окно для выбора AVI-файла, но по щелчку правой кнопки мыши. Функция OnCreate() инициализирует DirectDraw и AVI, а функция OnDestroy() завершает их работу.

Затем мы объявляем 10 закрытых (private) функций. Первой идет функция SelectInitialDisplayMode(), которая выполняет три задачи: выбор исходного видеорежима (то, для чего предназначена сама функция), построение списка 8-битных режимов для диалогового окна и захват системной палитры. Вскоре мы рассмотрим эту функцию. Функция GetSystemPalette() вызывается функцией SelectInitialDisplayMode(); мы увидим, как она работает, при знакомстве с последней.

Функция CreateCustomSurfaces() объявлена встроенной (inline). Она всего лишь возвращает TRUE, потому что при запуске приложения поверхности не создаются.

Следующая функция, ShowDialog(), отображает диалоговое окно и в случае выбора допустимого AVI-файла загружает его функцией LoadAvi(). Основная часть функциональных возможностей программы обеспечивается этими двумя функциями, поэтому мы рассмотрим их подробно.

За функций LoadAvi() объявляется функция DrawScene(). Мы воспользуется ею для вывода кадров видеоролика. Помимо извлечения и восстановления кадров видеопотока DrawScene() осуществляет блиттинг и переключение страниц, необходимые для отображения кадра.

Функция RestoreSurfaces() отвечает за восстановление поверхностей, хранящихся в видеопамяти, в случае их потери. Как вы вскоре убедитесь, в нашей программе эта функция выглядит примитивно.

Функции CreateAviSurface() и UpdateAviSurface() отвечают за создание и обновление поверхности AVI. Размеры поверхности AVI определяются размерами кадров AVI-файла, выбранного пользователем, поэтому при каждом открытии нового AVI-файла создается новая поверхность AVI. Функция UpdateAviSurface() готовит поверхность AVI к отображению, копируя выходные данные функции ICDecompress() в память поверхности.

Последней объявлена функция InstallPalette(), которая устанавливает палитру AVI перед началом воспроизведения ролика. Однако перед этим она должна извлечь данные палитры из потока AVI.

Оставшаяся часть класса содержит лишь переменные. Мы познакомимся с ними во время рассмотрения программы.

Мы будем рассматривать функции примерно в порядке их выполнения. Начнем с функции OnCreate(), которая выглядит так:

int AviPlayWin::OnCreate(LPCREATESTRUCT lpCreateStruct) {
 if (DirectDrawWin::OnCreate(lpCreateStruct) == -1) return -1;
 AVIFileInit();
 ShowDialog();
 return 0;
}

Сначала мы вызываем версию OnCreate() базового класса (а она инициализирует DirectDraw). Если вызов этой функции закончится неудачей, продолжать бессмысленно, и мы возвращаем код неудачного завершения –1.

Затем мы вызываем функцию AVIFileInit(), которая инициализирует Video For Windows. После этого можно спокойно пользоваться функциями VFW.

Наконец, функция ShowDialog() выводит диалоговое окно для выбора AVI-файла и ожидает ввод от пользователя. Однако перед тем, как обсуждать ShowDialog(), необходимо рассмотреть функцию SelectInitialDisplayMode(), которая вызывается при использовании функции OnCreate() класса DirectDrawWin.

Как упоминалось выше, функция SelectInitialDisplayMode() решает три задачи. Она выглядит так:

int AviPlayWin::SelectInitialDisplayMode() {
 GetSystemPalette();
 int i, nummodes=GetNumDisplayModes();
 DWORD w,h,d;
 for (i=0;i<nummodes;i++) {
  DisplayModeDescription desc;
  GetDisplayModeDimensions(i, w, h, d);
  if (d==8) {
   desc.w=w;
   desc.h=h;
   desc.d=d;
   desc.desc.Format("%dx%d", w, h);
   displaymode.Add(desc);
  }
 }
 int curdepth=GetDisplayDepth();
 if (curdepth!=8) ddraw2->SetDisplayMode(640, 480, curdepth, 0, 0);
 for (i=0;i<nummodes;i++) {
  GetDisplayModeDimensions(i, w, h, d);
  if (w==640 && h==480 && d==8) return i;
 }
 return 1;
}

Перед тем как выполнять свою основную задачу (выбор исходного видеорежима), функция SelectInitialDisplayMode() вызывает функцию GetSystemPalette(). В свою очередь GetSystemPalette() создает палитру DirectDraw на базе текущей палитры Windows. Эта палитра обеспечивает правильный вывод диалогового окна независимо от того, какая палитра была установлена для воспроизведения ролика. Вспомните — GDI ничего не знает о DirectDraw и поэтому всегда пытается вывести диалоговое окно с использованием системной палитры, несмотря на то что она могла быть переопределена DirectDraw.

Затем функция SelectInitialDisplayMode() перебирает список доступных видеорежимов и сохраняет описания 8-битных режимов в массиве displaymodes. Позднее этот массив передается диалоговому окну для вывода списка доступных видеорежимов.

Наконец, функция ищет 8-битный режим с разрешением 640x480. Этот режим выбран лишь потому, что он поддерживается абсолютным большинством видеокарт (если не всеми). После вывода диалогового окна пользователь сможет выбрать любой другой 8-битный режим.

Давайте рассмотрим функцию для вывода диалогового окна. Функция ShowDialog() приведена в листинге 8.2.

Листинг 8.2. Функция ShowDialog()

void AviPlayWin::ShowDialog() {
 const CRect& displayrect=GetDisplayRect();
 if (displayrect.Width()<640 || displayrect.Height()>480) ddraw2->SetDisplayMode(640, 480, 8, 0, 0);
 ClearSurface(backsurf, 0);
 ClearSurface(primsurf, 0);
 primsurf->SetPalette(syspal);
 ddraw2->FlipToGDISurface();
 ShowCursor(TRUE);
 if (avidialog==0) {
  avidialog=new AviDialog();
  avidialog->SetArray(&displaymode);
 }
 if (avistream)  AVIStreamRelease(avistream), avistream=0;
 if (avidialog->DoModal()==IDCANCEL) {
  PostMessage(WM_CLOSE);
  return;
 }
 ShowCursor(FALSE);
 fullfilename=avidialog->fullfilename;
 filename=avidialog->filename;
 pathname=avidialog->pathname;
 int index=avidialog->GetIndex();
 DWORD w,h,d;
 w=displaymode[index].w;
 h=displaymode[index].h;
 d=displaymode[index].d;
 ActivateDisplayMode(GetDisplayModeIndex(w, h, d));
 LoadAvi();
 CreateAviSurface();
 InstallPalette();
 curframe=startframe;
}

Функция ShowDialog() начинается с проверки текущего разрешения. Если в данный момент установлен видеорежим с разрешением меньше 640x480, он изменяется. Это сделано для того, чтобы диалоговое окно не выводилось в режиме Mode X. Поскольку этот режим не поддерживается Windows, такая попытка, скорее всего, закончится неудачей из-за нелинейной организации пикселей в режимах Mode X.

Возможно, у вас возник вопрос — а почему может действовать режим Mode X? Вспомните, что эта функция вызывается при каждом нажатии клавиши Escape, пробела или правой кнопки мыши во время воспроизведения видеоролика. Нельзя исключать того, что видеорежим Mode X был установлен для воспроизведения ролика, поэтому перед выводом диалогового окна необходимо проверить эту возможность.

Далее мы стираем первичную поверхность и вторичный буфер, после чего устанавливаем системную палитру. Строго говоря, стирать поверхности необязательно, но после восстановления системной палитры оставшиеся изображения будут выглядеть довольно странно.

После установки системной палитры мы вызываем функцию DirectDraw FlipToGDISurface(). Это гарантирует, что диалоговое окно Windows будет отображаться на видимой поверхности, а не во вторичном буфере. Кроме того, мы снова включаем курсор мыши (иначе пользователь не сможет нажимать кнопки диалогового окна и выбрать AVI-файл).

Если экземпляр класса AviDialog не был создан при предыдущем вызове функции ShowDialog(), мы создаем его. Обратите внимание на то, что при создании диалогового окна ему передается массив 8-битных видеорежимов, подготовленный в функции SelectInitialDisplayMode().

Затем мы закрываем существующий AVI-поток. Это делается из-за того, что класс AviDialog обладает собственными средствами для работы с файлами, с помощью которых он выводит размеры и количество кадров в выбранном AVI-файле. Если не закрыть ранее открытый файл, то при его повторном выборе диалоговое окно уже не сможет получить эту информацию.

Функция DoModal() отображает диалоговое окно, в котором пользователь может выбрать нужный файл. При нажатии кнопки Cancel мы посылаем сообщение WM_CLOSE. Если все идет нормально, мы получаем имя выбранного файла (в трех различных формах) вместе с индексом видеорежима (видеорежим необходимо выбрать до нажатия кнопки Play). Размеры выбранного видеорежима, взятые из массива displaymode, передаются функции SetDisplayMode().

Дальше следует вызов функции LoadAvi(). Как вы вскоре убедитесь, функция LoadAvi() на самом деле не загружает видеоролик — она лишь открывает файл и извлекает сведения о ролике (например, количество кадров и их размеры). Функция CreateAviSurface() по полученным размерам создает поверхность для хранения одного кадра видеопотока.

Функция InstallPalette() извлекает данные палитры из AVI-файла и строит по ним палитру DirectDraw, которая лучше всего подходит для просмотра. Наконец, переменной curframe, предназначенной для перебора кадров, присваивается значение переменной startframe.

Перейдем к функции, которая непосредственно открывает AVI-файл. Функция LoadAvi() приведена в листинге 8.3.

Листинг 8.3. Функция LoadAvi()

BOOL AviPlayWin::LoadAvi() {
 long r;
 CWaitCursor cur;
 if (avistream) AVIStreamRelease(avistream), avistream=0;
 r=AVIStreamOpenFromFile(&avistream, filename, streamtypeVIDEO, 0, OF_READ | OF_SHARE_EXCLUSIVE, 0);
 TRACE("AVIStreamOpenFromFile: %sn", r==0 ? "OK" : "failed");
 r=AVIStreamFormatSize(avistream, 0, &fmtlen);
 TRACE("AVIStreamFormatSize: %sn", r==0 ? "OK" : "failed");
 int formatsize=fmtlen+sizeof(RGBQUAD)*256;
 if (srcfmt)   delete [] srcfmt;
 srcfmt = (LPBITMAPINFOHEADER)new BYTE[formatsize];
 ZeroMemory(srcfmt, formatsize);
 if (dstfmt)   delete [] dstfmt;
 dstfmt = (LPBITMAPINFOHEADER)new BYTE[formatsize];
 ZeroMemory(dstfmt, formatsize);
 r=AVIStreamReadFormat(avistream, 0, srcfmt, &fmtlen);
 TRACE("AVIStreamReadFormat: %sn", r==0 ? "OK" : "failed");
 TRACE(" --- %s ---n", filename);
 TRACE(" biSize: %dn", srcfmt->biSize);
 TRACE(" biWidth x biHeight: %dx%dn", srcfmt->biWidth, srcfmt->biHeight);
 if (srcfmt->biPlanes != 1) TRACE(" - biPlanes: %dn", srcfmt->biPlanes);
 TRACE(" biBitCount: %dn", srcfmt->biBitCount);
 CString comp;
 switch (srcfmt->biCompression) {
 case BI_RGB:
  comp="BI_RGB";
  break;
 case BI_RLE8:
  comp="BI_RLE8";
  break;
 case BI_RLE4:
  comp="BI_RLE4";
  break;
 case BI_BITFIELDS:
  comp="BI_BITFIELDS";
  break;
 }
 TRACE(" biCompression: %sn", comp);
 TRACE(" biSizeImage: %dn", srcfmt->biSizeImage);
 TRACE(" ------------------n");
 memcpy(dstfmt, srcfmt, fmtlen);
 dstfmt->biBitCount = 8;
 dtfmt->biCompression = BI_RGB;
 dstfmt->biSizeImage = dstfmt->biWidth * dstfmt->biHeight;
 startframe = AVIStreamStart(avistream);
 TRACE("stream start: %dn", startframe);
 endframe = AVIStreamEnd(avistream);
 TRACE("stream end: %dn", endframe);
 r=AVIStreamInfo(avistream, &streaminfo, sizeof(streaminfo));
 TRACE("AVIStreamInfo: %sn", r==0 ? "OK" : "failed" );
 buflen = dstfmt->biSizeImage;
 int finalbuflen=((dstfmt->biWidth+3) & ~3) * dstfmt->biHeight;
 if (streaminfo.dwSuggestedBufferSize) if ((LONG)streaminfo.dwSuggestedBufferSize < buflen) {
  TRACE("adjusting buflen to suggested sizen");
  buflen = (LONG)streaminfo.dwSuggestedBufferSize;
 }
 if (decomp) ICClose(decomp);
 decomp = ICDecompressOpen(ICTYPE_VIDEO, streaminfo.fccHandler, srcfmt, dstfmt);
 TRACE("ICDecompressOpen: %sn", decomp ? "OK" : "failed");
 if (rawdata) {
  TRACE("delete [] rawdata...n");
  delete [] rawdata;
 }
 rawdata = new BYTE[buflen];
 if (finaldata) {
  TRACE("delete [] finaldata...n");
  delete [] finaldata;
 }
 finaldata = new BYTE[finalbuflen];
 return TRUE;
}

В функции LoadAvi() используются функции VFW. Сначала LoadAvi() закрывает открытый ранее AVI-поток функцией AVIStreamRelease(), а затем открывает новый поток функцией AVIStreamOpenFromFile(), которой в числе прочих аргументов передается имя открываемого AVI-файла.

Обратите внимание — третьим аргументом функции AVIStreamOpenFromFile() является флаг, определяющий тип открываемого потока. В нашем случае использован флаг видеопотока streamtypeVIDEO, но с помощью трех оставшихся флагов (streamtypeAUDIO, streamtypeMIDI и streamtypeTEXT) можно открывать и потоки других типов.

Затем мы получаем данные о формате потока функцией AVIStreamReadFormat() (пользуясь при этом функцией AVIStreamFormatSize()). Я специально оставил в этом фрагменте отладочные макросы TRACE(), чтобы продемонстрировать, какую информацию можно получить об AVI-файле.

На этой стадии инициализируются некоторые важные переменные класса. Например, мы присваиваем значения переменным startframe и endframe, чтобы во время извлечения кадров были известны допустимые значения их индексов.

Затем мы получаем доступ к декомпрессору. Функция ICDecompressorOpen() по структуре, описывающей AVI-файл и желательный формат вывода, возвращает логический номер модуля декомпрессии. Позднее этот модуль используется для восстановления кадров. Наконец, мы выделяем память под два буфера: в одном хранятся необработанные (сжатые) данные, извлеченные из AVI-потока, а в другом — итоговый (восстановленный) кадр.

Теперь у нашего приложения есть открытый AVI-поток и информация в объеме, достаточном для извлечения кадров. Но что же делать с кадром после того, как он будет прочитан и восстановлен? Нам понадобится поверхность для хранения полученных данных, и тогда воспроизведение видеоролика сведется к простому блиттингу содержимого этой поверхности во вторичный буфер приложения с последующим переключением страниц. Эта промежуточная поверхность создается функцией CreateAviSurface():

BOOL AviPlayWin::CreateAviSurface() {
 if (avisurf) avisurf->Release(), avisurf=0;
 avisurf=CreateSurface(srcfmt->biWidth, srcfmt->biHeight);
 CRect displayrect=GetDisplayRect();
 x=(displayrect.Width()-srcfmt->biWidth)/2;
 y=0;
 return TRUE;
}

После освобождения поверхности, созданной ранее, функция CreateAviSurface() с помощью функции CreateSurface() интерфейса DirectDraw создает поверхность, размеры которой совпадают с размерами кадра. Кроме того, функция CreateAviSurface() инициализирует переменные x и y, определяющие положение поверхности AVI на вторичном буфере. В нашем случае кадры будут выравниваться по центру экрана, поэтому в вычислениях применяется функция DirectDrawWin::GetDisplayRect() для определения размеров экрана.

С помощью файлового формата AVI и VFW API можно получить палитру, оптимально подходящую для просмотра видеоролика. Функция InstallPalette() извлекает необходимые данные и использует их для конструирования палитры DirectDraw. Функция InstallPalette() выглядит так:

BOOL AviPlayWin::InstallPalette() {
 ICDecompressGetPalette(decomp, srcfmt, dstfmt);
 PALETTEENTRY pe[256];
 LPBITMAPINFO info=(LPBITMAPINFO)dstfmt;
 for (int i=0; i<256; i++) {
  pe[i].peRed = info->bmiColors[i].rgbRed;
  pe[i].peGreen = info->bmiColors[i].rgbGreen;
  pe[i].peBlue = info->bmiColors[i].rgbBlue;
  pe[i].peFlags = 0;
 }
 if (avipal) avipal->Release();
 ddraw2->CreatePalette(DDPCAPS_8BIT, pe, &avipal, 0);
 primsurf->SetPalette(avipal);
 return TRUE;
}

Функция ICDecompressGetPalette() получает данные палитры и в цикле преобразует их в формат, который мы можем использовать. Полученный массив передается при вызове функции CreatePalette() интерфейса DirectDraw. Остается лишь присоединить созданную палитру к первичной поверхности.

Наконец, все готово к отображению кадров видеоролика. Для этого мы подготавливаем и выводим очередной кадр при каждом вызове функции DrawScene() классом DirectDrawWin. Функция DrawScene() выглядит так:

void AviPlayWin::DrawScene() {
 long r;
 r=AVIStreamRead(avistream, curframe, 1, rawdata, buflen, 0, 0);
 if (r) {
  TRACE("AVIStreamRead failed: ");
  switch (r)  {
  case AVIERR_BUFFERTOOSMALL:
   TRACE("BUFFERTOOSMALLn");
   break;
  case AVIERR_MEMORY:
   TRACE("MEMORYn");
   break;
  case AVIERR_FILEREAD:
   TRACE("FILEREADn");
   break;
  }
 }
 r=ICDecompress(decomp, 0, srcfmt, rawdata, dstfmt, finaldata);
 UpdateAviSurface();
 backsurf->BltFast(x, y, avisurf, 0, DDBLTFAST_WAIT);
 curframe=(curframe<endframe) ? curframe+1 : startframe;
 primsurf->Flip(0, DDFLIP_WAIT);
}

Функция DrawScene() с помощью функции AVIStreamRead() извлекает очередной кадр из AVI-потока, после чего сохраняет полученные данные в буфере rawdata. Я оставил в ней несколько макросов TRACE(), которые пригодились мне при отладке, но надеюсь, что вам они не понадобятся.

Затем мы вызываем функцию ICDecompress() и передаем ей логический номер декомпрессора, ранее полученный от функции LoadAvi(). Аргументами функции ICDecompress() являются два буфера — первый содержит необработанные (сжатые) данные, а второй — восстановленное изображение.

Функция UpdateAviSurface() копирует восстановленный кадр на поверхность AVI. Эта функция рассматривается ниже.

Подготовленная поверхность AVI копируется во вторичный буфер функцией BltFast() интерфейса DirectDrawSurface. После этого переменная curframe увеличивается или сбрасывается в зависимости от ее значения и количества кадров в ролике. Наконец, функция Flip() интерфейса DirectDrawSurface выводит кадр на экран.

Перед тем как рассматривать функцию UpdateAviSurface(), я хочу обратить ваше внимание на ее сходство с кодом класса DirectDrawWin, предназначенным для загрузки BMP-файлов на поверхность (см. главу 5). Функция UpdateAviSurface(), как и функции загрузки BMP-файлов DirectDrawWin, блокирует поверхность и затем копирует данные в ее память:

BOOL AviPlayWin::UpdateAviSurface() {
 HRESULT r;
 if (finaldata==0) return FALSE;
 DWORD dwWidth = (srcfmt->biWidth+3) & ~3;
 DWORD dwHeight = srcfmt->biHeight;
 DDSURFACEDESC desc;
 ZeroMemory(&desc, sizeof(desc));
 desc.dwSize = sizeof(desc);
 r = avisurf->Lock(0, &desc, DDLOCK_WAIT, 0);
 if (r==DD_OK) {
  BYTE* src = finaldata + dwWidth * (dwHeight-1);
  BYTE* dst = (BYTE *)desc.lpSurface;
  for (DWORD y=0; y<dwHeight; y++) {
   memcpy(dst, src, dwWidth);
   dst += desc.lPitch;
   src -= dwWidth;
  }
  avisurf->Unlock(0);
 }
 return TRUE;
}

После блокировки поверхности функция UpdateAviSurface() в цикле копирует каждую строку пикселей AVI-данных в память поверхности. В формате AVI, как и в формате BMP, изображения хранятся в перевернутом виде, поэтому мы начинаем с последней строки буфера данных и двигаемся к его началу.

Все трудное осталось позади, дальше будет легко. Особенно просто реализуется функция RestoreSurfaces():

void AviPlayWin::RestoreSurfaces() {
 avisurf->Restore();
}

Вспомните — функция RestoreSurfaces() вызывается только при восстановлении потерянных поверхностей, а класс DirectDrawWin автоматически восстанавливает первичную поверхность со вторичным буфером. В программе AviPlay остается лишь восстановить поверхность AVI, а для этого достаточно вызвать функцию Restore() интерфейса DirectDrawSurface.

В некоторых программах функция RestoreSurfaces() восстанавливала не только область памяти, но и содержимое поверхности. В нашем случае можно ограничиться восстановлением памяти, потому что ее содержимое будет перезаписано следующим кадром. Если вы вдруг засомневаетесь, напомню — вызов функции Restore() для поверхности, которая не была потеряна (например, находящейся в системной памяти), не причинит никакого вреда.

В программе AviPlay ввод не играет особой роли. Программа реагирует всего на три клавиши, причем одинаково. Ввод с клавиатуры обрабатывается функцией OnKeyDown():

void AviPlayWin::OnKeyDown(UINT key, UINT nRepCnt, UINT nFlags) {
 switch (key) {
 case VK_ESCAPE:
 case VK_SPACE:
 case VK_RETURN:
  ShowDialog();
  break;
 }
 DirectDrawWin::OnKeyDown(key, nRepCnt, nFlags);
}

Все три клавиши вызывают функцию ShowDialog(). Аналогично обрабатывается и ввод от мыши, это происходит в функции OnRButtonDown():

void AviPlayWin::OnRButtonDown(UINT nFlags, CPoint point) {
 ShowDialog();
 DirectDrawWin::OnRButtonDown(nFlags, point);
}

Когда пользователь закрывает диалоговое окно для выбора AVI-файла, функция ShowDialog() посылает сообщение WM_CLOSE, сигнализируя о завершении приложения.

Остается лишь завершить приложение. Функция OnDestroy() занимается «уборкой мусора» — она закрывает открытые AVI-потоки, освобождает декомпрессор и буферы данных AVI:

void AviPlayWin::OnDestroy() {
 DirectDrawWin::OnDestroy();
 if (avistream) AVIStreamRelease(avistream), avistream=0;
 if (decomp)  ICClose(decomp), decomp=0;
 if (srcfmt) delete [] srcfmt, srcfmt=0;
 if (dstfmt) delete [] dstfmt, dstfmt=0;
 if (rawdata) {
  TRACE("delete [] rawdata...n");
  delete [] rawdata, rawdata=0;
 }
 if (finaldata) {
  TRACE("delete [] finaldata...n");
  delete [] finaldata, finaldata=0;
 }
 if (avidialog) delete avidialog, avidialog=0;
 AVIFileExit();
}

Обратите внимание на вызов функции AviFileExit() в конце OnDestroy(). Это завершает работу VFW и освобождает все используемые им ресурсы.

Наше знакомство с воспроизведением видеороликов подходит к концу. Честно говоря, чтобы превратить программу AviPlay в полноценный проигрыватель AVI-файлов, вам придется еще немало потрудиться. Необходимо организовать поддержку звука и хронометраж, не говоря уже о том, что VFW обладает многими странностями и в работе с ним приходится много экспериментировать.

И последнее замечание. По неизвестным мне причинам VFW отказывается работать с AVI-файлами, сжатыми кодеками IR32 и IR42 (возможно, есть и другие, но я заметил эти два). С другой стороны, AVI-файлы, использующие кодеки MS-CRAM и Cinepak, работают нормально.

В главе 9 мы возьмемся за проверку столкновений. Наша цель — написать код, который бы обеспечивал точность проверки на уровне пикселей при максимальной эффективности.

Оглавление книги