ReactOS  0.4.14-dev-77-gd9e7c48
msvideo1.c File Reference
#include <stdarg.h>
#include "windef.h"
#include "winbase.h"
#include "wingdi.h"
#include "winuser.h"
#include "commdlg.h"
#include "vfw.h"
#include "mmsystem.h"
#include "msvidc32_private.h"
#include "wine/debug.h"
Include dependency graph for msvideo1.c:

Go to the source code of this file.

Classes

struct  Msvideo1Context
 

Macros

#define CRAM_MAGIC   mmioFOURCC('C', 'R', 'A', 'M')
 
#define MSVC_MAGIC   mmioFOURCC('M', 'S', 'V', 'C')
 
#define WHAM_MAGIC   mmioFOURCC('W', 'H', 'A', 'M')
 
#define compare_fourcc(fcc1, fcc2)   (((fcc1)^(fcc2))&~0x20202020)
 
#define PALETTE_COUNT   256
 
#define LE_16(x)   ((((const uint8_t *)(x))[1] << 8) | ((const uint8_t *)(x))[0])
 
#define CHECK_STREAM_PTR(n)
 

Typedefs

typedef BYTE uint8_t
 
typedef struct Msvideo1Context Msvideo1Context
 

Functions

 WINE_DEFAULT_DEBUG_CHANNEL (msvidc32)
 
static int get_stride (int width, int depth)
 
static void msvideo1_decode_8bit (int width, int height, const unsigned char *buf, int buf_size, unsigned char *pixels, int stride)
 
static void msvideo1_decode_16bit (int width, int height, const unsigned char *buf, int buf_size, unsigned short *pixels, int stride)
 
static LRESULT CRAM_DecompressQuery (Msvideo1Context *info, LPBITMAPINFO in, LPBITMAPINFO out)
 
static LRESULT CRAM_DecompressGetFormat (Msvideo1Context *info, LPBITMAPINFO in, LPBITMAPINFO out)
 
static LRESULT CRAM_DecompressBegin (Msvideo1Context *info, LPBITMAPINFO in, LPBITMAPINFO out)
 
static void convert_depth (char *input, int depth_in, char *output, BITMAPINFOHEADER *out_hdr)
 
static LRESULT CRAM_Decompress (Msvideo1Context *info, ICDECOMPRESS *icd, DWORD size)
 
static LRESULT CRAM_DecompressEx (Msvideo1Context *info, ICDECOMPRESSEX *icd, DWORD size)
 
static LRESULT CRAM_GetInfo (const Msvideo1Context *info, ICINFO *icinfo, DWORD dwSize)
 
LRESULT WINAPI CRAM_DriverProc (DWORD_PTR dwDriverId, HDRVR hdrvr, UINT msg, LPARAM lParam1, LPARAM lParam2)
 
BOOL WINAPI DllMain (HINSTANCE hModule, DWORD dwReason, LPVOID lpReserved)
 

Variables

static HINSTANCE MSVIDC32_hModule
 

Detailed Description

Microsoft Video-1 Decoder by Mike Melanson (melan.nosp@m.son@.nosp@m.pcisy.nosp@m.s.ne.nosp@m.t) For more information about the MS Video-1 format, visit: http://www.pcisys.net/~melanson/codecs/

This decoder outputs either PAL8 or RGB555 data, depending on the whether a RGB palette was passed through palctrl; if it's present, then the data is PAL8; RGB555 otherwise.

Definition in file msvideo1.c.

Macro Definition Documentation

◆ CHECK_STREAM_PTR

#define CHECK_STREAM_PTR (   n)
Value:
if ((stream_ptr + n) > buf_size ) { \
WARN("stream_ptr out of bounds (%d >= %d)\n", \
stream_ptr + n, buf_size); \
return; \
}
GLdouble n
Definition: glext.h:7729

Definition at line 59 of file msvideo1.c.

◆ compare_fourcc

#define compare_fourcc (   fcc1,
  fcc2 
)    (((fcc1)^(fcc2))&~0x20202020)

Definition at line 53 of file msvideo1.c.

◆ CRAM_MAGIC

#define CRAM_MAGIC   mmioFOURCC('C', 'R', 'A', 'M')

Definition at line 50 of file msvideo1.c.

◆ LE_16

#define LE_16 (   x)    ((((const uint8_t *)(x))[1] << 8) | ((const uint8_t *)(x))[0])

Definition at line 56 of file msvideo1.c.

◆ MSVC_MAGIC

#define MSVC_MAGIC   mmioFOURCC('M', 'S', 'V', 'C')

Definition at line 51 of file msvideo1.c.

◆ PALETTE_COUNT

#define PALETTE_COUNT   256

Definition at line 55 of file msvideo1.c.

◆ WHAM_MAGIC

#define WHAM_MAGIC   mmioFOURCC('W', 'H', 'A', 'M')

Definition at line 52 of file msvideo1.c.

Typedef Documentation

◆ Msvideo1Context

◆ uint8_t

typedef BYTE uint8_t

Definition at line 66 of file msvideo1.c.

Function Documentation

◆ convert_depth()

static void convert_depth ( char input,
int  depth_in,
char output,
BITMAPINFOHEADER out_hdr 
)
static

Definition at line 408 of file msvideo1.c.

409 {
410  int x, y;
411  int stride_in = get_stride(out_hdr->biWidth, depth_in);
412  int stride_out = get_stride(out_hdr->biWidth, out_hdr->biBitCount);
413 
414  if (depth_in == 16 && out_hdr->biBitCount == 24)
415  {
416  static const unsigned char convert_5to8[] =
417  {
418  0x00, 0x08, 0x10, 0x19, 0x21, 0x29, 0x31, 0x3a,
419  0x42, 0x4a, 0x52, 0x5a, 0x63, 0x6b, 0x73, 0x7b,
420  0x84, 0x8c, 0x94, 0x9c, 0xa5, 0xad, 0xb5, 0xbd,
421  0xc5, 0xce, 0xd6, 0xde, 0xe6, 0xef, 0xf7, 0xff,
422  };
423 
424  for (y = 0; y < out_hdr->biHeight; y++)
425  {
426  WORD *src_row = (WORD *)(input + y * stride_in);
427  char *out_row = output + y * stride_out;
428 
429  for (x = 0; x < out_hdr->biWidth; x++)
430  {
431  WORD pixel = *src_row++;
432  *out_row++ = convert_5to8[(pixel & 0x7c00u) >> 10];
433  *out_row++ = convert_5to8[(pixel & 0x03e0u) >> 5];
434  *out_row++ = convert_5to8[(pixel & 0x001fu)];
435  }
436  }
437  }
438  else
439  FIXME("Conversion from %d to %d bit unimplemented\n", depth_in, out_hdr->biBitCount);
440 }
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble * u
Definition: glfuncs.h:240
static UCHAR ULONG UCHAR ULONG UCHAR * output
Definition: bcrypt.c:29
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
#define FIXME(fmt,...)
Definition: debug.h:110
static int get_stride(int width, int depth)
Definition: msvideo1.c:73
unsigned short WORD
Definition: ntddk_ex.h:93
GLenum GLenum GLenum input
Definition: glext.h:9031
GLint GLint GLint GLint GLint GLint y
Definition: gl.h:1548

Referenced by CRAM_Decompress(), and CRAM_DecompressEx().

◆ CRAM_Decompress()

static LRESULT CRAM_Decompress ( Msvideo1Context info,
ICDECOMPRESS icd,
DWORD  size 
)
static

Definition at line 442 of file msvideo1.c.

443 {
444  LONG width, height, stride, sz;
445  void *output;
446 
447  TRACE("ICM_DECOMPRESS %p %p %d\n", info, icd, size);
448 
449  if( (info==NULL) || (info->dwMagic!=CRAM_MAGIC) )
450  return ICERR_BADPARAM;
451 
452  /* FIXME: flags are ignored */
453 
454  width = icd->lpbiInput->biWidth;
455  height = icd->lpbiInput->biHeight;
456  sz = icd->lpbiInput->biSizeImage;
457 
458  output = icd->lpOutput;
459 
460  if (icd->lpbiOutput->biBitCount != info->depth)
461  {
462  output = HeapAlloc(GetProcessHeap(), 0, icd->lpbiOutput->biWidth * icd->lpbiOutput->biHeight * info->depth / 8);
463  if (!output) return ICERR_MEMORY;
464  }
465 
466  if (info->depth == 8)
467  {
468  stride = get_stride(width, 8);
469  msvideo1_decode_8bit( width, height, icd->lpInput, sz,
470  output, stride );
471  }
472  else
473  {
474  stride = get_stride(width, 16) / 2;
475  msvideo1_decode_16bit( width, height, icd->lpInput, sz,
476  output, stride );
477  }
478 
479  if (icd->lpbiOutput->biBitCount != info->depth)
480  {
481  convert_depth(output, info->depth, icd->lpOutput, icd->lpbiOutput);
483  }
484 
485  return ICERR_OK;
486 }
GLint GLint GLsizei width
Definition: gl.h:1546
#define CRAM_MAGIC
Definition: msvideo1.c:50
static UCHAR ULONG UCHAR ULONG UCHAR * output
Definition: bcrypt.c:29
LPBITMAPINFOHEADER lpbiInput
Definition: vfw.h:335
#define ICERR_OK
Definition: vfw.h:50
#define ICERR_MEMORY
Definition: vfw.h:58
long LONG
Definition: pedump.c:60
static int get_stride(int width, int depth)
Definition: msvideo1.c:73
smooth NULL
Definition: ftsmooth.c:416
#define TRACE(s)
Definition: solgame.cpp:4
GLsizei stride
Definition: glext.h:5848
GLsizeiptr size
Definition: glext.h:5919
#define GetProcessHeap()
Definition: compat.h:395
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
#define ICERR_BADPARAM
Definition: vfw.h:61
DWORD biSizeImage
Definition: amvideo.idl:36
static void msvideo1_decode_16bit(int width, int height, const unsigned char *buf, int buf_size, unsigned short *pixels, int stride)
Definition: msvideo1.c:183
GLint GLint GLsizei GLsizei height
Definition: gl.h:1546
static void msvideo1_decode_8bit(int width, int height, const unsigned char *buf, int buf_size, unsigned char *pixels, int stride)
Definition: msvideo1.c:79
LPBITMAPINFOHEADER lpbiOutput
Definition: vfw.h:337
static void convert_depth(char *input, int depth_in, char *output, BITMAPINFOHEADER *out_hdr)
Definition: msvideo1.c:408
#define HeapFree(x, y, z)
Definition: compat.h:394

Referenced by CRAM_DriverProc().

◆ CRAM_DecompressBegin()

static LRESULT CRAM_DecompressBegin ( Msvideo1Context info,
LPBITMAPINFO  in,
LPBITMAPINFO  out 
)
static

Definition at line 387 of file msvideo1.c.

388 {
389  TRACE("ICM_DECOMPRESS_BEGIN %p %p %p\n", info, in, out);
390 
391  if( (info==NULL) || (info->dwMagic!=CRAM_MAGIC) )
392  return ICERR_BADPARAM;
393 
394  TRACE("bitmap is %d bpp\n", in->bmiHeader.biBitCount);
395  if( in->bmiHeader.biBitCount == 8 )
396  info->depth = 8;
397  else if( in->bmiHeader.biBitCount == 16 )
398  info->depth = 16;
399  else
400  {
401  info->depth = 0;
402  FIXME("Unsupported output format %i\n", in->bmiHeader.biBitCount);
403  }
404 
405  return ICERR_OK;
406 }
#define CRAM_MAGIC
Definition: msvideo1.c:50
#define ICERR_OK
Definition: vfw.h:50
#define FIXME(fmt,...)
Definition: debug.h:110
smooth NULL
Definition: ftsmooth.c:416
#define TRACE(s)
Definition: solgame.cpp:4
#define ICERR_BADPARAM
Definition: vfw.h:61
static FILE * out
Definition: regtests2xml.c:44
GLuint in
Definition: glext.h:9616

Referenced by CRAM_DriverProc().

◆ CRAM_DecompressEx()

static LRESULT CRAM_DecompressEx ( Msvideo1Context info,
ICDECOMPRESSEX icd,
DWORD  size 
)
static

Definition at line 488 of file msvideo1.c.

489 {
490  LONG width, height, stride, sz;
491  void *output;
492 
493  TRACE("ICM_DECOMPRESSEX %p %p %d\n", info, icd, size);
494 
495  if( (info==NULL) || (info->dwMagic!=CRAM_MAGIC) )
496  return ICERR_BADPARAM;
497 
498  /* FIXME: flags are ignored */
499 
500  width = icd->lpbiSrc->biWidth;
501  height = icd->lpbiSrc->biHeight;
502  sz = icd->lpbiSrc->biSizeImage;
503 
504  output = icd->lpDst;
505 
506  if (icd->lpbiDst->biBitCount != info->depth)
507  {
508  output = HeapAlloc(GetProcessHeap(), 0, icd->lpbiDst->biWidth * icd->lpbiDst->biHeight * info->depth / 8);
509  if (!output) return ICERR_MEMORY;
510  }
511 
512  if (info->depth == 8)
513  {
514  stride = get_stride(width, 8);
515  msvideo1_decode_8bit( width, height, icd->lpSrc, sz,
516  output, stride );
517  }
518  else
519  {
520  stride = get_stride(width, 16) / 2;
522  output, stride );
523  }
524 
525  if (icd->lpbiDst->biBitCount != info->depth)
526  {
527  convert_depth(output, info->depth, icd->lpDst, icd->lpbiDst);
529  }
530 
531  return ICERR_OK;
532 }
GLint GLint GLsizei width
Definition: gl.h:1546
#define CRAM_MAGIC
Definition: msvideo1.c:50
static UCHAR ULONG UCHAR ULONG UCHAR * output
Definition: bcrypt.c:29
LPVOID lpSrc
Definition: vfw.h:345
#define ICERR_OK
Definition: vfw.h:50
#define ICERR_MEMORY
Definition: vfw.h:58
LPVOID lpDst
Definition: vfw.h:347
long LONG
Definition: pedump.c:60
LPBITMAPINFOHEADER lpbiSrc
Definition: vfw.h:344
static int get_stride(int width, int depth)
Definition: msvideo1.c:73
smooth NULL
Definition: ftsmooth.c:416
#define TRACE(s)
Definition: solgame.cpp:4
GLsizei stride
Definition: glext.h:5848
GLsizeiptr size
Definition: glext.h:5919
#define GetProcessHeap()
Definition: compat.h:395
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
#define ICERR_BADPARAM
Definition: vfw.h:61
DWORD biSizeImage
Definition: amvideo.idl:36
static void msvideo1_decode_16bit(int width, int height, const unsigned char *buf, int buf_size, unsigned short *pixels, int stride)
Definition: msvideo1.c:183
GLint GLint GLsizei GLsizei height
Definition: gl.h:1546
static void msvideo1_decode_8bit(int width, int height, const unsigned char *buf, int buf_size, unsigned char *pixels, int stride)
Definition: msvideo1.c:79
LPBITMAPINFOHEADER lpbiDst
Definition: vfw.h:346
static void convert_depth(char *input, int depth_in, char *output, BITMAPINFOHEADER *out_hdr)
Definition: msvideo1.c:408
#define HeapFree(x, y, z)
Definition: compat.h:394

Referenced by CRAM_DriverProc().

◆ CRAM_DecompressGetFormat()

static LRESULT CRAM_DecompressGetFormat ( Msvideo1Context info,
LPBITMAPINFO  in,
LPBITMAPINFO  out 
)
static

Definition at line 357 of file msvideo1.c.

358 {
359  DWORD size;
360 
361  TRACE("ICM_DECOMPRESS_GETFORMAT %p %p %p\n", info, in, out);
362 
363  if( (info==NULL) || (info->dwMagic!=CRAM_MAGIC) )
364  return ICERR_BADPARAM;
365 
366  size = in->bmiHeader.biSize;
367  if (in->bmiHeader.biBitCount <= 8)
368  size += in->bmiHeader.biClrUsed * sizeof(RGBQUAD);
369 
370  if (in->bmiHeader.biBitCount != 8 && in->bmiHeader.biBitCount != 16)
371  return ICERR_BADFORMAT;
372 
373  if( out )
374  {
375  memcpy( out, in, size );
376  out->bmiHeader.biWidth = in->bmiHeader.biWidth & ~1;
377  out->bmiHeader.biHeight = in->bmiHeader.biHeight & ~1;
378  out->bmiHeader.biCompression = BI_RGB;
379  out->bmiHeader.biSizeImage = in->bmiHeader.biHeight *
380  get_stride(out->bmiHeader.biWidth, out->bmiHeader.biBitCount);
381  return ICERR_OK;
382  }
383 
384  return size;
385 }
#define CRAM_MAGIC
Definition: msvideo1.c:50
#define ICERR_OK
Definition: vfw.h:50
static int get_stride(int width, int depth)
Definition: msvideo1.c:73
smooth NULL
Definition: ftsmooth.c:416
struct tagRGBQUAD RGBQUAD
#define ICERR_BADFORMAT
Definition: vfw.h:57
#define TRACE(s)
Definition: solgame.cpp:4
GLsizeiptr size
Definition: glext.h:5919
#define ICERR_BADPARAM
Definition: vfw.h:61
static FILE * out
Definition: regtests2xml.c:44
unsigned long DWORD
Definition: ntddk_ex.h:95
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
GLuint in
Definition: glext.h:9616
#define BI_RGB
Definition: precomp.h:34

Referenced by CRAM_DriverProc().

◆ CRAM_DecompressQuery()

static LRESULT CRAM_DecompressQuery ( Msvideo1Context info,
LPBITMAPINFO  in,
LPBITMAPINFO  out 
)
static

Definition at line 300 of file msvideo1.c.

301 {
302  TRACE("ICM_DECOMPRESS_QUERY %p %p %p\n", info, in, out);
303 
304  if( (info==NULL) || (info->dwMagic!=CRAM_MAGIC) )
305  return ICERR_BADPARAM;
306 
307  TRACE("in->planes = %d\n", in->bmiHeader.biPlanes );
308  TRACE("in->bpp = %d\n", in->bmiHeader.biBitCount );
309  TRACE("in->height = %d\n", in->bmiHeader.biHeight );
310  TRACE("in->width = %d\n", in->bmiHeader.biWidth );
311  TRACE("in->compr = 0x%x\n", in->bmiHeader.biCompression );
312 
313  if( ( in->bmiHeader.biCompression != CRAM_MAGIC ) &&
314  ( in->bmiHeader.biCompression != MSVC_MAGIC ) &&
315  ( in->bmiHeader.biCompression != WHAM_MAGIC ) )
316  {
317  TRACE("can't do 0x%x compression\n", in->bmiHeader.biCompression);
318  return ICERR_BADFORMAT;
319  }
320 
321  if( ( in->bmiHeader.biBitCount != 16 ) &&
322  ( in->bmiHeader.biBitCount != 8 ) )
323  {
324  TRACE("can't do %d bpp\n", in->bmiHeader.biBitCount );
325  return ICERR_BADFORMAT;
326  }
327 
328  /* output must be same dimensions as input */
329  if( out )
330  {
331  TRACE("out->planes = %d\n", out->bmiHeader.biPlanes );
332  TRACE("out->bpp = %d\n", out->bmiHeader.biBitCount );
333  TRACE("out->height = %d\n", out->bmiHeader.biHeight );
334  TRACE("out->width = %d\n", out->bmiHeader.biWidth );
335 
336  if ((in->bmiHeader.biBitCount != out->bmiHeader.biBitCount) &&
337  (in->bmiHeader.biBitCount != 16 || out->bmiHeader.biBitCount != 24))
338  {
339  TRACE("incompatible depth requested\n");
340  return ICERR_BADFORMAT;
341  }
342 
343  if(( in->bmiHeader.biPlanes != out->bmiHeader.biPlanes ) ||
344  ( in->bmiHeader.biHeight != out->bmiHeader.biHeight ) ||
345  ( in->bmiHeader.biWidth != out->bmiHeader.biWidth ))
346  {
347  TRACE("incompatible output requested\n");
348  return ICERR_BADFORMAT;
349  }
350  }
351 
352  TRACE("OK!\n");
353  return ICERR_OK;
354 }
#define CRAM_MAGIC
Definition: msvideo1.c:50
#define WHAM_MAGIC
Definition: msvideo1.c:52
#define ICERR_OK
Definition: vfw.h:50
#define MSVC_MAGIC
Definition: msvideo1.c:51
smooth NULL
Definition: ftsmooth.c:416
#define ICERR_BADFORMAT
Definition: vfw.h:57
#define TRACE(s)
Definition: solgame.cpp:4
#define ICERR_BADPARAM
Definition: vfw.h:61
static FILE * out
Definition: regtests2xml.c:44
GLuint in
Definition: glext.h:9616

Referenced by CRAM_DriverProc().

◆ CRAM_DriverProc()

LRESULT WINAPI CRAM_DriverProc ( DWORD_PTR  dwDriverId,
HDRVR  hdrvr,
UINT  msg,
LPARAM  lParam1,
LPARAM  lParam2 
)

Definition at line 556 of file msvideo1.c.

558 {
559  Msvideo1Context *info = (Msvideo1Context *) dwDriverId;
561 
562  TRACE("%ld %p %04x %08lx %08lx\n", dwDriverId, hdrvr, msg, lParam1, lParam2);
563 
564  switch( msg )
565  {
566  case DRV_LOAD:
567  TRACE("Loaded\n");
568  r = 1;
569  break;
570 
571  case DRV_ENABLE:
572  break;
573 
574  case DRV_OPEN:
575  {
576  ICINFO *icinfo = (ICINFO *)lParam2;
577 
578  TRACE("Opened\n");
579 
580  if (icinfo && compare_fourcc(icinfo->fccType, ICTYPE_VIDEO)) return 0;
581 
582  info = HeapAlloc( GetProcessHeap(), 0, sizeof (Msvideo1Context) );
583  if( info )
584  {
585  memset( info, 0, sizeof *info );
586  info->dwMagic = CRAM_MAGIC;
587  }
588  r = (LRESULT) info;
589  break;
590  }
591 
592  case DRV_CLOSE:
593  HeapFree( GetProcessHeap(), 0, info );
594  break;
595 
596  case DRV_DISABLE:
597  break;
598 
599  case DRV_FREE:
600  break;
601 
602  case ICM_GETINFO:
603  r = CRAM_GetInfo( info, (ICINFO *)lParam1, (DWORD)lParam2 );
604  break;
605 
607  r = CRAM_DecompressQuery( info, (LPBITMAPINFO) lParam1,
608  (LPBITMAPINFO) lParam2 );
609  break;
610 
613  (LPBITMAPINFO) lParam2 );
614  break;
615 
617  FIXME("ICM_DECOMPRESS_GET_PALETTE\n");
618  break;
619 
621  FIXME("ICM_DECOMPRESSEX_QUERY\n");
622  break;
623 
624  case ICM_DECOMPRESS:
625  r = CRAM_Decompress( info, (ICDECOMPRESS*) lParam1,
626  (DWORD) lParam2 );
627  break;
628 
630  r = CRAM_DecompressBegin( info, (LPBITMAPINFO) lParam1,
631  (LPBITMAPINFO) lParam2 );
632  break;
633 
634  case ICM_DECOMPRESSEX:
635  r = CRAM_DecompressEx( info, (ICDECOMPRESSEX*) lParam1,
636  (DWORD) lParam2 );
637  break;
638 
639  case ICM_DECOMPRESS_END:
640  r = ICERR_OK;
641  break;
642 
643  case ICM_COMPRESS_QUERY:
644  r = ICERR_BADFORMAT;
645  /* fall through */
647  case ICM_COMPRESS_END:
648  case ICM_COMPRESS:
649  FIXME("compression not implemented\n");
650  break;
651 
652  case ICM_CONFIGURE:
653  break;
654 
655  default:
656  FIXME("Unknown message: %04x %ld %ld\n", msg, lParam1, lParam2);
657  }
658 
659  return r;
660 }
#define ICM_DECOMPRESSEX_QUERY
Definition: vfw.h:139
#define DRV_DISABLE
Definition: mmsystem.h:123
static LRESULT CRAM_GetInfo(const Msvideo1Context *info, ICINFO *icinfo, DWORD dwSize)
Definition: msvideo1.c:534
static LRESULT CRAM_DecompressEx(Msvideo1Context *info, ICDECOMPRESSEX *icd, DWORD size)
Definition: msvideo1.c:488
#define CRAM_MAGIC
Definition: msvideo1.c:50
static LRESULT CRAM_DecompressBegin(Msvideo1Context *info, LPBITMAPINFO in, LPBITMAPINFO out)
Definition: msvideo1.c:387
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
#define DRV_CLOSE
Definition: mmsystem.h:122
#define ICERR_OK
Definition: vfw.h:50
#define compare_fourcc(fcc1, fcc2)
Definition: msvideo1.c:53
#define ICM_COMPRESS_QUERY
Definition: vfw.h:101
#define ICM_GETINFO
Definition: vfw.h:82
#define DRV_OPEN
Definition: mmsystem.h:121
#define ICM_DECOMPRESS_QUERY
Definition: vfw.h:107
#define FIXME(fmt,...)
Definition: debug.h:110
static LRESULT CRAM_Decompress(Msvideo1Context *info, ICDECOMPRESS *icd, DWORD size)
Definition: msvideo1.c:442
#define DRV_LOAD(x)
#define ICERR_BADFORMAT
Definition: vfw.h:57
#define TRACE(s)
Definition: solgame.cpp:4
#define GetProcessHeap()
Definition: compat.h:395
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
#define ICM_DECOMPRESS_GET_PALETTE
Definition: vfw.h:112
#define ICM_DECOMPRESS_GET_FORMAT
Definition: vfw.h:106
#define ICTYPE_VIDEO
Definition: mmreg.h:531
#define ICM_DECOMPRESS_END
Definition: vfw.h:110
unsigned long DWORD
Definition: ntddk_ex.h:95
DWORD fccType
Definition: vfw.h:282
static LRESULT CRAM_DecompressGetFormat(Msvideo1Context *info, LPBITMAPINFO in, LPBITMAPINFO out)
Definition: msvideo1.c:357
#define DRV_FREE
Definition: mmsystem.h:124
#define ICM_COMPRESS
Definition: vfw.h:103
#define ICERR_UNSUPPORTED
Definition: vfw.h:56
#define ICM_DECOMPRESS
Definition: vfw.h:109
#define LRESULT
Definition: ole.h:14
#define ICM_DECOMPRESS_BEGIN
Definition: vfw.h:108
#define DRV_ENABLE
Definition: mmsystem.h:120
#define ICM_COMPRESS_GET_FORMAT
Definition: vfw.h:99
Definition: vfw.h:280
ICINFO icinfo
Definition: msvideo_main.c:885
#define ICM_COMPRESS_END
Definition: vfw.h:104
#define msg(x)
Definition: auth_time.c:54
#define ICM_DECOMPRESSEX
Definition: vfw.h:140
LONG_PTR LRESULT
Definition: windef.h:209
static LRESULT CRAM_DecompressQuery(Msvideo1Context *info, LPBITMAPINFO in, LPBITMAPINFO out)
Definition: msvideo1.c:300
#define memset(x, y, z)
Definition: compat.h:39
#define ICM_CONFIGURE
Definition: vfw.h:84
#define HeapFree(x, y, z)
Definition: compat.h:394

◆ CRAM_GetInfo()

static LRESULT CRAM_GetInfo ( const Msvideo1Context info,
ICINFO icinfo,
DWORD  dwSize 
)
static

Definition at line 534 of file msvideo1.c.

535 {
536  if (!icinfo) return sizeof(ICINFO);
537  if (dwSize < sizeof(ICINFO)) return 0;
538 
539  icinfo->dwSize = sizeof(ICINFO);
541  icinfo->fccHandler = info ? info->dwMagic : CRAM_MAGIC;
542  icinfo->dwFlags = 0;
545 
548  /* msvfw32 will fill icinfo->szDriver for us */
549 
550  return sizeof(ICINFO);
551 }
DWORD dwVersion
Definition: vfw.h:285
#define CRAM_MAGIC
Definition: msvideo1.c:50
#define ICVERSION
Definition: vfw.h:45
DWORD dwSize
Definition: vfw.h:281
static HINSTANCE MSVIDC32_hModule
Definition: msvideo1.c:48
DWORD dwFlags
Definition: vfw.h:284
#define IDS_DESCRIPTION
Definition: resource.h:92
int WINAPI LoadStringW(_In_opt_ HINSTANCE hInstance, _In_ UINT uID, _Out_writes_to_(cchBufferMax, return+1) LPWSTR lpBuffer, _In_ int cchBufferMax)
DWORD fccHandler
Definition: vfw.h:283
WCHAR szDescription[128]
Definition: vfw.h:291
#define ICTYPE_VIDEO
Definition: mmreg.h:531
DWORD fccType
Definition: vfw.h:282
WCHAR szName[16]
Definition: vfw.h:290
Definition: vfw.h:280
ICINFO icinfo
Definition: msvideo_main.c:885
#define ARRAY_SIZE(a)
Definition: main.h:24
#define IDS_NAME
Definition: resource.h:90
DWORD dwVersionICM
Definition: vfw.h:286
PSDBQUERYRESULT_VISTA PVOID DWORD * dwSize
Definition: env.c:54

Referenced by CRAM_DriverProc().

◆ DllMain()

BOOL WINAPI DllMain ( HINSTANCE  hModule,
DWORD  dwReason,
LPVOID  lpReserved 
)

Definition at line 665 of file msvideo1.c.

666 {
667  TRACE("(%p,%d,%p)\n", hModule, dwReason, lpReserved);
668 
669  switch (dwReason)
670  {
671  case DLL_PROCESS_ATTACH:
674  break;
675  }
676  return TRUE;
677 }
#define TRUE
Definition: types.h:120
static HINSTANCE MSVIDC32_hModule
Definition: msvideo1.c:48
BOOL WINAPI DisableThreadLibraryCalls(IN HMODULE hLibModule)
Definition: loader.c:85
#define DLL_PROCESS_ATTACH
Definition: compat.h:120
DWORD dwReason
Definition: misc.cpp:154
#define TRACE(s)
Definition: solgame.cpp:4
HMODULE hModule
Definition: animate.c:44

◆ get_stride()

static int get_stride ( int  width,
int  depth 
)
inlinestatic

Definition at line 73 of file msvideo1.c.

74 {
75  return ((depth * width + 31) >> 3) & ~3;
76 }
GLint GLint GLsizei width
Definition: gl.h:1546
GLint GLint GLsizei GLsizei GLsizei depth
Definition: gl.h:1546

Referenced by convert_depth(), CRAM_Decompress(), CRAM_DecompressEx(), and CRAM_DecompressGetFormat().

◆ msvideo1_decode_16bit()

static void msvideo1_decode_16bit ( int  width,
int  height,
const unsigned char buf,
int  buf_size,
unsigned short pixels,
int  stride 
)
static

Definition at line 183 of file msvideo1.c.

185 {
186  int block_ptr, pixel_ptr;
187  int total_blocks;
188  int pixel_x, pixel_y; /* pixel width and height iterators */
189  int block_x, block_y; /* block width and height iterators */
190  int blocks_wide, blocks_high; /* width and height in 4x4 blocks */
191  int block_inc;
192  int row_dec;
193 
194  /* decoding parameters */
195  int stream_ptr;
196  unsigned char byte_a, byte_b;
197  unsigned short flags;
198  int skip_blocks;
199  unsigned short colors[8];
200 
201  stream_ptr = 0;
202  skip_blocks = 0;
203  blocks_wide = width / 4;
204  blocks_high = height / 4;
205  total_blocks = blocks_wide * blocks_high;
206  block_inc = 4;
207 #ifdef ORIGINAL
208  row_dec = stride + 4;
209 #else
210  row_dec = - (stride - 4); /* such that -row_dec > 0 */
211 #endif
212 
213  for (block_y = blocks_high; block_y > 0; block_y--) {
214 #ifdef ORIGINAL
215  block_ptr = ((block_y * 4) - 1) * stride;
216 #else
217  block_ptr = ((blocks_high - block_y) * 4) * stride;
218 #endif
219  for (block_x = blocks_wide; block_x > 0; block_x--) {
220  /* check if this block should be skipped */
221  if (skip_blocks) {
222  block_ptr += block_inc;
223  skip_blocks--;
224  total_blocks--;
225  continue;
226  }
227 
228  pixel_ptr = block_ptr;
229 
230  /* get the next two bytes in the encoded data stream */
231  CHECK_STREAM_PTR(2);
232  byte_a = buf[stream_ptr++];
233  byte_b = buf[stream_ptr++];
234 
235  /* check if the decode is finished */
236  if ((byte_a == 0) && (byte_b == 0) && (total_blocks == 0)) {
237  return;
238  } else if ((byte_b & 0xFC) == 0x84) {
239  /* skip code, but don't count the current block */
240  skip_blocks = ((byte_b - 0x84) << 8) + byte_a - 1;
241  } else if (byte_b < 0x80) {
242  /* 2- or 8-color encoding modes */
243  flags = (byte_b << 8) | byte_a;
244 
245  CHECK_STREAM_PTR(4);
246  colors[0] = LE_16(&buf[stream_ptr]);
247  stream_ptr += 2;
248  colors[1] = LE_16(&buf[stream_ptr]);
249  stream_ptr += 2;
250 
251  if (colors[0] & 0x8000) {
252  /* 8-color encoding */
253  CHECK_STREAM_PTR(12);
254  colors[2] = LE_16(&buf[stream_ptr]);
255  stream_ptr += 2;
256  colors[3] = LE_16(&buf[stream_ptr]);
257  stream_ptr += 2;
258  colors[4] = LE_16(&buf[stream_ptr]);
259  stream_ptr += 2;
260  colors[5] = LE_16(&buf[stream_ptr]);
261  stream_ptr += 2;
262  colors[6] = LE_16(&buf[stream_ptr]);
263  stream_ptr += 2;
264  colors[7] = LE_16(&buf[stream_ptr]);
265  stream_ptr += 2;
266 
267  for (pixel_y = 0; pixel_y < 4; pixel_y++) {
268  for (pixel_x = 0; pixel_x < 4; pixel_x++, flags >>= 1)
269  pixels[pixel_ptr++] =
270  colors[((pixel_y & 0x2) << 1) +
271  (pixel_x & 0x2) + ((flags & 0x1) ^ 1)];
272  pixel_ptr -= row_dec;
273  }
274  } else {
275  /* 2-color encoding */
276  for (pixel_y = 0; pixel_y < 4; pixel_y++) {
277  for (pixel_x = 0; pixel_x < 4; pixel_x++, flags >>= 1)
278  pixels[pixel_ptr++] = colors[(flags & 0x1) ^ 1];
279  pixel_ptr -= row_dec;
280  }
281  }
282  } else {
283  /* otherwise, it's a 1-color block */
284  colors[0] = (byte_b << 8) | byte_a;
285 
286  for (pixel_y = 0; pixel_y < 4; pixel_y++) {
287  for (pixel_x = 0; pixel_x < 4; pixel_x++)
288  pixels[pixel_ptr++] = colors[0];
289  pixel_ptr -= row_dec;
290  }
291  }
292 
293  block_ptr += block_inc;
294  total_blocks--;
295  }
296  }
297 }
GLint GLint GLsizei width
Definition: gl.h:1546
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
_In_ CLIPOBJ _In_ BRUSHOBJ _In_ LONG x1
Definition: winddi.h:3706
#define LE_16(x)
Definition: msvideo1.c:56
GLsizei stride
Definition: glext.h:5848
GLbitfield flags
Definition: glext.h:7161
GLint GLint GLsizei GLsizei height
Definition: gl.h:1546
#define CHECK_STREAM_PTR(n)
Definition: msvideo1.c:59
GLint GLint GLsizei GLsizei GLsizei GLint GLenum GLenum const GLvoid * pixels
Definition: gl.h:1546
_In_ CLIPOBJ _In_ BRUSHOBJ _In_ LONG _In_ LONG _In_ LONG x2
Definition: winddi.h:3706

Referenced by CRAM_Decompress(), and CRAM_DecompressEx().

◆ msvideo1_decode_8bit()

static void msvideo1_decode_8bit ( int  width,
int  height,
const unsigned char buf,
int  buf_size,
unsigned char pixels,
int  stride 
)
static

Definition at line 79 of file msvideo1.c.

81 {
82  int block_ptr, pixel_ptr;
83  int total_blocks;
84  int pixel_x, pixel_y; /* pixel width and height iterators */
85  int block_x, block_y; /* block width and height iterators */
86  int blocks_wide, blocks_high; /* width and height in 4x4 blocks */
87  int block_inc;
88  int row_dec;
89 
90  /* decoding parameters */
91  int stream_ptr;
92  unsigned char byte_a, byte_b;
93  unsigned short flags;
94  int skip_blocks;
95  unsigned char colors[8];
96 
97  stream_ptr = 0;
98  skip_blocks = 0;
99  blocks_wide = width / 4;
100  blocks_high = height / 4;
101  total_blocks = blocks_wide * blocks_high;
102  block_inc = 4;
103 #ifdef ORIGINAL
104  row_dec = stride + 4;
105 #else
106  row_dec = - (stride - 4); /* such that -row_dec > 0 */
107 #endif
108 
109  for (block_y = blocks_high; block_y > 0; block_y--) {
110 #ifdef ORIGINAL
111  block_ptr = ((block_y * 4) - 1) * stride;
112 #else
113  block_ptr = ((blocks_high - block_y) * 4) * stride;
114 #endif
115  for (block_x = blocks_wide; block_x > 0; block_x--) {
116  /* check if this block should be skipped */
117  if (skip_blocks) {
118  block_ptr += block_inc;
119  skip_blocks--;
120  total_blocks--;
121  continue;
122  }
123 
124  pixel_ptr = block_ptr;
125 
126  /* get the next two bytes in the encoded data stream */
127  CHECK_STREAM_PTR(2);
128  byte_a = buf[stream_ptr++];
129  byte_b = buf[stream_ptr++];
130 
131  /* check if the decode is finished */
132  if ((byte_a == 0) && (byte_b == 0) && (total_blocks == 0))
133  return;
134  else if ((byte_b & 0xFC) == 0x84) {
135  /* skip code, but don't count the current block */
136  skip_blocks = ((byte_b - 0x84) << 8) + byte_a - 1;
137  } else if (byte_b < 0x80) {
138  /* 2-color encoding */
139  flags = (byte_b << 8) | byte_a;
140 
141  CHECK_STREAM_PTR(2);
142  colors[0] = buf[stream_ptr++];
143  colors[1] = buf[stream_ptr++];
144 
145  for (pixel_y = 0; pixel_y < 4; pixel_y++) {
146  for (pixel_x = 0; pixel_x < 4; pixel_x++, flags >>= 1)
147  pixels[pixel_ptr++] = colors[(flags & 0x1) ^ 1];
148  pixel_ptr -= row_dec;
149  }
150  } else if (byte_b >= 0x90) {
151  /* 8-color encoding */
152  flags = (byte_b << 8) | byte_a;
153 
154  CHECK_STREAM_PTR(8);
155  memcpy(colors, &buf[stream_ptr], 8);
156  stream_ptr += 8;
157 
158  for (pixel_y = 0; pixel_y < 4; pixel_y++) {
159  for (pixel_x = 0; pixel_x < 4; pixel_x++, flags >>= 1)
160  pixels[pixel_ptr++] =
161  colors[((pixel_y & 0x2) << 1) +
162  (pixel_x & 0x2) + ((flags & 0x1) ^ 1)];
163  pixel_ptr -= row_dec;
164  }
165  } else {
166  /* 1-color encoding */
167  colors[0] = byte_a;
168 
169  for (pixel_y = 0; pixel_y < 4; pixel_y++) {
170  for (pixel_x = 0; pixel_x < 4; pixel_x++)
171  pixels[pixel_ptr++] = colors[0];
172  pixel_ptr -= row_dec;
173  }
174  }
175 
176  block_ptr += block_inc;
177  total_blocks--;
178  }
179  }
180 }
GLint GLint GLsizei width
Definition: gl.h:1546
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
_In_ CLIPOBJ _In_ BRUSHOBJ _In_ LONG x1
Definition: winddi.h:3706
GLsizei stride
Definition: glext.h:5848
GLbitfield flags
Definition: glext.h:7161
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
GLint GLint GLsizei GLsizei height
Definition: gl.h:1546
#define CHECK_STREAM_PTR(n)
Definition: msvideo1.c:59
GLint GLint GLsizei GLsizei GLsizei GLint GLenum GLenum const GLvoid * pixels
Definition: gl.h:1546
_In_ CLIPOBJ _In_ BRUSHOBJ _In_ LONG _In_ LONG _In_ LONG x2
Definition: winddi.h:3706

Referenced by CRAM_Decompress(), and CRAM_DecompressEx().

◆ WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL ( msvidc32  )

Variable Documentation

◆ MSVIDC32_hModule

HINSTANCE MSVIDC32_hModule
static

Definition at line 48 of file msvideo1.c.

Referenced by CRAM_GetInfo(), and DllMain().