archive/blender-archive
Archived
1
1
Fork 0
Code Pull Requests Packages Activity

style cleanup: avi

Browse Source
This commit is contained in:
Campbell Barton
2012-05-07 18:30:04 +00:00
parent a314b70930
commit e5faeab5d6
7 changed files with 774 additions and 753 deletions
Download Patch File Download Diff File Expand all files Collapse all files

681
source/blender/avi/intern/avi.c
View File

File diff suppressed because it is too large Load Diff

84
source/blender/avi/intern/avirgb.c
View File

@@ -42,108 +42,108 @@
/* implementation */
void *avi_converter_from_avi_rgb (AviMovie *movie, int stream, unsigned char *buffer, int *size)
void *avi_converter_from_avi_rgb(AviMovie *movie, int stream, unsigned char *buffer, int *size)
{
int x, y, i, rowstride;
unsigned char *buf;
AviBitmapInfoHeader *bi;
short bits= 32;
short bits = 32;
(void)size; /* unused */
bi= (AviBitmapInfoHeader *) movie->streams[stream].sf;
if (bi) bits= bi->BitCount;
bi = (AviBitmapInfoHeader *) movie->streams[stream].sf;
if (bi) bits = bi->BitCount;
if (bits==16) {
if (bits == 16) {
unsigned short *pxl;
unsigned char *to;
#ifdef __BIG_ENDIAN__
unsigned char *pxla;
#endif
buf = MEM_mallocN (movie->header->Height * movie->header->Width * 3, "fromavirgbbuf");
buf = MEM_mallocN(movie->header->Height * movie->header->Width * 3, "fromavirgbbuf");
y= movie->header->Height;
to= buf;
y = movie->header->Height;
to = buf;
while (y--) {
pxl= (unsigned short *) (buffer + y * movie->header->Width * 2);
pxl = (unsigned short *) (buffer + y * movie->header->Width * 2);
#ifdef __BIG_ENDIAN__
pxla= (unsigned char *)pxl;
pxla = (unsigned char *)pxl;
#endif
x= movie->header->Width;
x = movie->header->Width;
while (x--) {
#ifdef __BIG_ENDIAN__
i= pxla[0];
pxla[0]= pxla[1];
pxla[1]= i;
i = pxla[0];
pxla[0] = pxla[1];
pxla[1] = i;
pxla+=2;
pxla += 2;
#endif
*(to++)= ((*pxl>>10)&0x1f)*8;
*(to++)= ((*pxl>>5)&0x1f)*8;
*(to++)= (*pxl&0x1f)*8;
*(to++) = ((*pxl >> 10) & 0x1f) * 8;
*(to++) = ((*pxl >> 5) & 0x1f) * 8;
*(to++) = (*pxl & 0x1f) * 8;
pxl++;
}
}
MEM_freeN (buffer);
MEM_freeN(buffer);
return buf;
}
else {
buf = MEM_mallocN (movie->header->Height * movie->header->Width * 3, "fromavirgbbuf");
buf = MEM_mallocN(movie->header->Height * movie->header->Width * 3, "fromavirgbbuf");
rowstride = movie->header->Width*3;
if (bits!=16) if (movie->header->Width%2) rowstride++;
rowstride = movie->header->Width * 3;
if (bits != 16) if (movie->header->Width % 2) rowstride++;
for (y=0; y < movie->header->Height; y++) {
memcpy (&buf[y*movie->header->Width*3], &buffer[((movie->header->Height-1)-y)*rowstride], movie->header->Width*3);
for (y = 0; y < movie->header->Height; y++) {
memcpy(&buf[y * movie->header->Width * 3], &buffer[((movie->header->Height - 1) - y) * rowstride], movie->header->Width * 3);
}
for (y=0; y < movie->header->Height*movie->header->Width*3; y+=3) {
for (y = 0; y < movie->header->Height * movie->header->Width * 3; y += 3) {
i = buf[y];
buf[y] = buf[y+2];
buf[y+2] = i;
buf[y] = buf[y + 2];
buf[y + 2] = i;
}
MEM_freeN (buffer);
MEM_freeN(buffer);
return buf;
}
}
void *avi_converter_to_avi_rgb (AviMovie *movie, int stream, unsigned char *buffer, int *size)
void *avi_converter_to_avi_rgb(AviMovie *movie, int stream, unsigned char *buffer, int *size)
{
int y, x, i, rowstride;
unsigned char *buf;
(void)stream; /* unused */
*size= movie->header->Height * movie->header->Width * 3;
if (movie->header->Width%2) *size+= movie->header->Height;
*size = movie->header->Height * movie->header->Width * 3;
if (movie->header->Width % 2) *size += movie->header->Height;
buf = MEM_mallocN (*size, "toavirgbbuf");
buf = MEM_mallocN(*size, "toavirgbbuf");
rowstride = movie->header->Width*3;
if (movie->header->Width%2) rowstride++;
rowstride = movie->header->Width * 3;
if (movie->header->Width % 2) rowstride++;
for (y=0; y < movie->header->Height; y++) {
memcpy (&buf[y*rowstride], &buffer[((movie->header->Height-1)-y)*movie->header->Width*3], movie->header->Width*3);
for (y = 0; y < movie->header->Height; y++) {
memcpy(&buf[y * rowstride], &buffer[((movie->header->Height - 1) - y) * movie->header->Width * 3], movie->header->Width * 3);
}
for (y=0; y < movie->header->Height; y++) {
for (x=0; x < movie->header->Width*3; x+=3) {
i = buf[y*rowstride+x];
buf[y*rowstride+x] = buf[y*rowstride+x+2];
buf[y*rowstride+x+2] = i;
for (y = 0; y < movie->header->Height; y++) {
for (x = 0; x < movie->header->Width * 3; x += 3) {
i = buf[y * rowstride + x];
buf[y * rowstride + x] = buf[y * rowstride + x + 2];
buf[y * rowstride + x + 2] = i;
}
}
MEM_freeN (buffer);
MEM_freeN(buffer);
return buf;
}

108
source/blender/avi/intern/codecs.c
View File

@@ -39,7 +39,7 @@
#include "mjpeg.h"
#include "rgb32.h"
void *avi_format_convert (AviMovie *movie, int stream, void *buffer, AviFormat from, AviFormat to, int *size)
void *avi_format_convert(AviMovie *movie, int stream, void *buffer, AviFormat from, AviFormat to, int *size)
{
if (from == to)
return buffer;
@@ -53,32 +53,32 @@ void *avi_format_convert (AviMovie *movie, int stream, void *buffer, AviFormat f
}
switch (to) {
case AVI_FORMAT_RGB24:
switch (from) {
case AVI_FORMAT_RGB24:
switch (from) {
case AVI_FORMAT_AVI_RGB:
buffer = avi_converter_from_avi_rgb(movie, stream, buffer, size);
break;
case AVI_FORMAT_MJPEG:
buffer = avi_converter_from_mjpeg(movie, stream, buffer, size);
break;
case AVI_FORMAT_RGB32:
buffer = avi_converter_from_rgb32(movie, stream, buffer, size);
break;
default:
break;
}
break;
case AVI_FORMAT_AVI_RGB:
buffer = avi_converter_from_avi_rgb (movie, stream, buffer, size);
buffer = avi_converter_to_avi_rgb(movie, stream, buffer, size);
break;
case AVI_FORMAT_MJPEG:
buffer = avi_converter_from_mjpeg (movie, stream, buffer, size);
buffer = avi_converter_to_mjpeg(movie, stream, buffer, size);
break;
case AVI_FORMAT_RGB32:
buffer = avi_converter_from_rgb32 (movie, stream, buffer, size);
buffer = avi_converter_to_rgb32(movie, stream, buffer, size);
break;
default:
break;
}
break;
case AVI_FORMAT_AVI_RGB:
buffer = avi_converter_to_avi_rgb (movie, stream, buffer, size);
break;
case AVI_FORMAT_MJPEG:
buffer = avi_converter_to_mjpeg (movie, stream, buffer, size);
break;
case AVI_FORMAT_RGB32:
buffer = avi_converter_to_rgb32 (movie, stream, buffer, size);
break;
default:
break;
}
return buffer;
@@ -88,10 +88,10 @@ int avi_get_data_id(AviFormat format, int stream)
{
char fcc[5];
if (avi_get_format_type (format) == FCC("vids"))
sprintf (fcc, "%2.2ddc", stream);
else if (avi_get_format_type (format) == FCC("auds"))
sprintf (fcc, "%2.2ddc", stream);
if (avi_get_format_type(format) == FCC("vids"))
sprintf(fcc, "%2.2ddc", stream);
else if (avi_get_format_type(format) == FCC("auds"))
sprintf(fcc, "%2.2ddc", stream);
else
return 0;
@@ -101,48 +101,48 @@ int avi_get_data_id(AviFormat format, int stream)
int avi_get_format_type(AviFormat format)
{
switch (format) {
case AVI_FORMAT_RGB24:
case AVI_FORMAT_RGB32:
case AVI_FORMAT_AVI_RGB:
case AVI_FORMAT_MJPEG:
return FCC("vids");
break;
default:
return 0;
break;
case AVI_FORMAT_RGB24:
case AVI_FORMAT_RGB32:
case AVI_FORMAT_AVI_RGB:
case AVI_FORMAT_MJPEG:
return FCC("vids");
break;
default:
return 0;
break;
}
}
int avi_get_format_fcc(AviFormat format)
{
switch (format) {
case AVI_FORMAT_RGB24:
case AVI_FORMAT_RGB32:
case AVI_FORMAT_AVI_RGB:
return FCC("DIB ");
break;
case AVI_FORMAT_MJPEG:
return FCC("MJPG");
break;
default:
return 0;
break;
case AVI_FORMAT_RGB24:
case AVI_FORMAT_RGB32:
case AVI_FORMAT_AVI_RGB:
return FCC("DIB ");
break;
case AVI_FORMAT_MJPEG:
return FCC("MJPG");
break;
default:
return 0;
break;
}
}
int avi_get_format_compression(AviFormat format)
{
switch (format) {
case AVI_FORMAT_RGB24:
case AVI_FORMAT_RGB32:
case AVI_FORMAT_AVI_RGB:
return 0;
break;
case AVI_FORMAT_MJPEG:
return FCC("MJPG");
break;
default:
return 0;
break;
case AVI_FORMAT_RGB24:
case AVI_FORMAT_RGB32:
case AVI_FORMAT_AVI_RGB:
return 0;
break;
case AVI_FORMAT_MJPEG:
return FCC("MJPG");
break;
default:
return 0;
break;
}
}

242
source/blender/avi/intern/endian.c
View File

@@ -46,125 +46,125 @@
#endif
#ifdef __BIG_ENDIAN__
static void invert (int *num)
static void invert(int *num)
{
int new=0, i, j;
int new = 0, i, j;
for (j=0; j < 4; j++) {
for (i=0; i<8; i++) {
new |= ((*num>>(j*8+i))&1)<<((3-j)*8+i);
for (j = 0; j < 4; j++) {
for (i = 0; i < 8; i++) {
new |= ((*num >> (j * 8 + i)) & 1) << ((3 - j) * 8 + i);
}
}
*num = new;
}
static void sinvert (short int *num)
static void sinvert(short int *num)
{
short int new=0;
short int new = 0;
int i, j;
for (j=0; j < 2; j++) {
for (i=0; i<8; i++) {
new |= ((*num>>(j*8+i))&1)<<((1-j)*8+i);
for (j = 0; j < 2; j++) {
for (i = 0; i < 8; i++) {
new |= ((*num >> (j * 8 + i)) & 1) << ((1 - j) * 8 + i);
}
}
*num = new;
}
static void Ichunk (AviChunk *chunk)
static void Ichunk(AviChunk *chunk)
{
invert (&chunk->fcc);
invert (&chunk->size);
invert(&chunk->fcc);
invert(&chunk->size);
}
#endif
#ifdef __BIG_ENDIAN__
static void Ilist (AviList *list)
static void Ilist(AviList *list)
{
invert (&list->fcc);
invert (&list->size);
invert (&list->ids);
invert(&list->fcc);
invert(&list->size);
invert(&list->ids);
}
static void Imainh (AviMainHeader *mainh)
static void Imainh(AviMainHeader *mainh)
{
invert (&mainh->fcc);
invert (&mainh->size);
invert (&mainh->MicroSecPerFrame);
invert (&mainh->MaxBytesPerSec);
invert (&mainh->PaddingGranularity);
invert (&mainh->Flags);
invert (&mainh->TotalFrames);
invert (&mainh->InitialFrames);
invert (&mainh->Streams);
invert (&mainh->SuggestedBufferSize);
invert (&mainh->Width);
invert (&mainh->Height);
invert (&mainh->Reserved[0]);
invert (&mainh->Reserved[1]);
invert (&mainh->Reserved[2]);
invert (&mainh->Reserved[3]);
invert(&mainh->fcc);
invert(&mainh->size);
invert(&mainh->MicroSecPerFrame);
invert(&mainh->MaxBytesPerSec);
invert(&mainh->PaddingGranularity);
invert(&mainh->Flags);
invert(&mainh->TotalFrames);
invert(&mainh->InitialFrames);
invert(&mainh->Streams);
invert(&mainh->SuggestedBufferSize);
invert(&mainh->Width);
invert(&mainh->Height);
invert(&mainh->Reserved[0]);
invert(&mainh->Reserved[1]);
invert(&mainh->Reserved[2]);
invert(&mainh->Reserved[3]);
}
static void Istreamh (AviStreamHeader *streamh)
static void Istreamh(AviStreamHeader *streamh)
{
invert (&streamh->fcc);
invert (&streamh->size);
invert (&streamh->Type);
invert (&streamh->Handler);
invert (&streamh->Flags);
sinvert (&streamh->Priority);
sinvert (&streamh->Language);
invert (&streamh->InitialFrames);
invert (&streamh->Scale);
invert (&streamh->Rate);
invert (&streamh->Start);
invert (&streamh->Length);
invert (&streamh->SuggestedBufferSize);
invert (&streamh->Quality);
invert (&streamh->SampleSize);
sinvert (&streamh->left);
sinvert (&streamh->right);
sinvert (&streamh->top);
sinvert (&streamh->bottom);
invert(&streamh->fcc);
invert(&streamh->size);
invert(&streamh->Type);
invert(&streamh->Handler);
invert(&streamh->Flags);
sinvert(&streamh->Priority);
sinvert(&streamh->Language);
invert(&streamh->InitialFrames);
invert(&streamh->Scale);
invert(&streamh->Rate);
invert(&streamh->Start);
invert(&streamh->Length);
invert(&streamh->SuggestedBufferSize);
invert(&streamh->Quality);
invert(&streamh->SampleSize);
sinvert(&streamh->left);
sinvert(&streamh->right);
sinvert(&streamh->top);
sinvert(&streamh->bottom);
}
static void Ibitmaph (AviBitmapInfoHeader *bitmaph)
static void Ibitmaph(AviBitmapInfoHeader *bitmaph)
{
invert (&bitmaph->fcc);
invert (&bitmaph->size);
invert (&bitmaph->Size);
invert (&bitmaph->Width);
invert (&bitmaph->Height);
sinvert (&bitmaph->Planes);
sinvert (&bitmaph->BitCount);
invert (&bitmaph->Compression);
invert (&bitmaph->SizeImage);
invert (&bitmaph->XPelsPerMeter);
invert (&bitmaph->YPelsPerMeter);
invert (&bitmaph->ClrUsed);
invert (&bitmaph->ClrImportant);
invert(&bitmaph->fcc);
invert(&bitmaph->size);
invert(&bitmaph->Size);
invert(&bitmaph->Width);
invert(&bitmaph->Height);
sinvert(&bitmaph->Planes);
sinvert(&bitmaph->BitCount);
invert(&bitmaph->Compression);
invert(&bitmaph->SizeImage);
invert(&bitmaph->XPelsPerMeter);
invert(&bitmaph->YPelsPerMeter);
invert(&bitmaph->ClrUsed);
invert(&bitmaph->ClrImportant);
}
static void Imjpegu (AviMJPEGUnknown *mjpgu)
static void Imjpegu(AviMJPEGUnknown *mjpgu)
{
invert (&mjpgu->a);
invert (&mjpgu->b);
invert (&mjpgu->c);
invert (&mjpgu->d);
invert (&mjpgu->e);
invert (&mjpgu->f);
invert (&mjpgu->g);
invert(&mjpgu->a);
invert(&mjpgu->b);
invert(&mjpgu->c);
invert(&mjpgu->d);
invert(&mjpgu->e);
invert(&mjpgu->f);
invert(&mjpgu->g);
}
static void Iindexe (AviIndexEntry *indexe)
static void Iindexe(AviIndexEntry *indexe)
{
invert (&indexe->ChunkId);
invert (&indexe->Flags);
invert (&indexe->Offset);
invert (&indexe->Size);
invert(&indexe->ChunkId);
invert(&indexe->Flags);
invert(&indexe->Offset);
invert(&indexe->Size);
}
#endif /* __BIG_ENDIAN__ */
@@ -173,53 +173,53 @@ void awrite(AviMovie *movie, void *datain, int block, int size, FILE *fp, int ty
#ifdef __BIG_ENDIAN__
void *data;
data = MEM_mallocN (size, "avi endian");
data = MEM_mallocN(size, "avi endian");
memcpy (data, datain, size);
memcpy(data, datain, size);
switch (type) {
case AVI_RAW:
fwrite (data, block, size, fp);
break;
case AVI_CHUNK:
Ichunk ((AviChunk *) data);
fwrite (data, block, size, fp);
break;
case AVI_LIST:
Ilist ((AviList *) data);
fwrite (data, block, size, fp);
break;
case AVI_MAINH:
Imainh ((AviMainHeader *) data);
fwrite (data, block, size, fp);
break;
case AVI_STREAMH:
Istreamh ((AviStreamHeader *) data);
fwrite (data, block, size, fp);
break;
case AVI_BITMAPH:
Ibitmaph ((AviBitmapInfoHeader *) data);
if (size==sizeof(AviBitmapInfoHeader) + sizeof(AviMJPEGUnknown)) {
Imjpegu((AviMJPEGUnknown*)((char*)data+sizeof(AviBitmapInfoHeader)));
}
fwrite (data, block, size, fp);
break;
case AVI_MJPEGU:
Imjpegu ((AviMJPEGUnknown *) data);
fwrite (data, block, size, fp);
break;
case AVI_INDEXE:
Iindexe ((AviIndexEntry *) data);
fwrite (data, block, size, fp);
break;
default:
break;
case AVI_RAW:
fwrite(data, block, size, fp);
break;
case AVI_CHUNK:
Ichunk((AviChunk *) data);
fwrite(data, block, size, fp);
break;
case AVI_LIST:
Ilist((AviList *) data);
fwrite(data, block, size, fp);
break;
case AVI_MAINH:
Imainh((AviMainHeader *) data);
fwrite(data, block, size, fp);
break;
case AVI_STREAMH:
Istreamh((AviStreamHeader *) data);
fwrite(data, block, size, fp);
break;
case AVI_BITMAPH:
Ibitmaph((AviBitmapInfoHeader *) data);
if (size == sizeof(AviBitmapInfoHeader) + sizeof(AviMJPEGUnknown)) {
Imjpegu((AviMJPEGUnknown *)((char *)data + sizeof(AviBitmapInfoHeader)));
}
fwrite(data, block, size, fp);
break;
case AVI_MJPEGU:
Imjpegu((AviMJPEGUnknown *) data);
fwrite(data, block, size, fp);
break;
case AVI_INDEXE:
Iindexe((AviIndexEntry *) data);
fwrite(data, block, size, fp);
break;
default:
break;
}
MEM_freeN (data);
MEM_freeN(data);
#else /* __BIG_ENDIAN__ */
(void)movie; /* unused */
(void)type; /* unused */
fwrite (datain, block, size, fp);
fwrite(datain, block, size, fp);
#endif /* __BIG_ENDIAN__ */
}

246
source/blender/avi/intern/mjpeg.c
View File

@@ -42,14 +42,14 @@
#include "mjpeg.h"
#define PADUP(num, amt) ((num+(amt-1))&~(amt-1))
#define PADUP(num, amt) ((num + (amt - 1)) & ~(amt - 1))
static void jpegmemdestmgr_build (j_compress_ptr cinfo, unsigned char *buffer, int bufsize);
static void jpegmemsrcmgr_build (j_decompress_ptr dinfo, unsigned char *buffer, int bufsize);
static void jpegmemdestmgr_build(j_compress_ptr cinfo, unsigned char *buffer, int bufsize);
static void jpegmemsrcmgr_build(j_decompress_ptr dinfo, unsigned char *buffer, int bufsize);
static int numbytes;
static void add_huff_table (j_decompress_ptr dinfo, JHUFF_TBL **htblptr, const UINT8 *bits, const UINT8 *val)
static void add_huff_table(j_decompress_ptr dinfo, JHUFF_TBL **htblptr, const UINT8 *bits, const UINT8 *val)
{
if (*htblptr == NULL)
*htblptr = jpeg_alloc_huff_table((j_common_ptr) dinfo);
@@ -64,25 +64,30 @@ static void add_huff_table (j_decompress_ptr dinfo, JHUFF_TBL **htblptr, const U
/* Set up the standard Huffman tables (cf. JPEG standard section K.3) */
/* IMPORTANT: these are only valid for 8-bit data precision! */
static void std_huff_tables (j_decompress_ptr dinfo)
static void std_huff_tables(j_decompress_ptr dinfo)
{
static const UINT8 bits_dc_luminance[17] =
{ /* 0-base */
0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0 };
0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0
};
static const UINT8 val_dc_luminance[] =
{
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11
};
static const UINT8 bits_dc_chrominance[17] =
{ /* 0-base */
0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 };
0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0
};
static const UINT8 val_dc_chrominance[] =
{
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11
};
static const UINT8 bits_ac_luminance[17] =
{ /* 0-base */
0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d };
0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d
};
static const UINT8 val_ac_luminance[] =
{
0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
@@ -105,10 +110,12 @@ static void std_huff_tables (j_decompress_ptr dinfo)
0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
0xf9, 0xfa };
0xf9, 0xfa
};
static const UINT8 bits_ac_chrominance[17] =
{ /* 0-base */
0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77 };
0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77
};
static const UINT8 val_ac_chrominance[] =
{
0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
@@ -131,16 +138,17 @@ static void std_huff_tables (j_decompress_ptr dinfo)
0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
0xf9, 0xfa };
0xf9, 0xfa
};
add_huff_table(dinfo, &dinfo->dc_huff_tbl_ptrs[0],
bits_dc_luminance, val_dc_luminance);
bits_dc_luminance, val_dc_luminance);
add_huff_table(dinfo, &dinfo->ac_huff_tbl_ptrs[0],
bits_ac_luminance, val_ac_luminance);
bits_ac_luminance, val_ac_luminance);
add_huff_table(dinfo, &dinfo->dc_huff_tbl_ptrs[1],
bits_dc_chrominance, val_dc_chrominance);
bits_dc_chrominance, val_dc_chrominance);
add_huff_table(dinfo, &dinfo->ac_huff_tbl_ptrs[1],
bits_ac_chrominance, val_ac_chrominance);
bits_ac_chrominance, val_ac_chrominance);
}
static int Decode_JPEG(unsigned char *inBuffer, unsigned char *outBuffer, unsigned int width, unsigned int height, int bufsize)
@@ -152,7 +160,7 @@ static int Decode_JPEG(unsigned char *inBuffer, unsigned char *outBuffer, unsign
(void)width; /* unused */
numbytes= 0;
numbytes = 0;
dinfo.err = jpeg_std_error(&jerr);
jpeg_create_decompress(&dinfo);
@@ -166,8 +174,8 @@ static int Decode_JPEG(unsigned char *inBuffer, unsigned char *outBuffer, unsign
jpeg_start_decompress(&dinfo);
rowstride= dinfo.output_width*dinfo.output_components;
for (y= 0; y<dinfo.output_height; y++) {
rowstride = dinfo.output_width * dinfo.output_components;
for (y = 0; y < dinfo.output_height; y++) {
jpeg_read_scanlines(&dinfo, (JSAMPARRAY) &outBuffer, 1);
outBuffer += rowstride;
}
@@ -175,18 +183,18 @@ static int Decode_JPEG(unsigned char *inBuffer, unsigned char *outBuffer, unsign
if (dinfo.output_height >= height) return 0;
inBuffer+= numbytes;
jpegmemsrcmgr_build(&dinfo, inBuffer, bufsize-numbytes);
inBuffer += numbytes;
jpegmemsrcmgr_build(&dinfo, inBuffer, bufsize - numbytes);
numbytes= 0;
numbytes = 0;
jpeg_read_header(&dinfo, TRUE);
if (dinfo.dc_huff_tbl_ptrs[0] == NULL) {
std_huff_tables(&dinfo);
}
jpeg_start_decompress(&dinfo);
rowstride= dinfo.output_width*dinfo.output_components;
for (y= 0; y<dinfo.output_height; y++) {
rowstride = dinfo.output_width * dinfo.output_components;
for (y = 0; y < dinfo.output_height; y++) {
jpeg_read_scanlines(&dinfo, (JSAMPARRAY) &outBuffer, 1);
outBuffer += rowstride;
}
@@ -214,9 +222,9 @@ static void Compress_JPEG(int quality, unsigned char *outbuffer, unsigned char *
cinfo.in_color_space = JCS_RGB;
jpeg_set_defaults(&cinfo);
jpeg_set_colorspace (&cinfo, JCS_YCbCr);
jpeg_set_colorspace(&cinfo, JCS_YCbCr);
jpeg_set_quality (&cinfo, quality, TRUE);
jpeg_set_quality(&cinfo, quality, TRUE);
cinfo.dc_huff_tbl_ptrs[0]->sent_table = TRUE;
cinfo.dc_huff_tbl_ptrs[1]->sent_table = TRUE;
@@ -232,24 +240,24 @@ static void Compress_JPEG(int quality, unsigned char *outbuffer, unsigned char *
jpeg_start_compress(&cinfo, FALSE);
i=0;
i = 0;
marker[i++] = 'A';
marker[i++] = 'V';
marker[i++] = 'I';
marker[i++] = '1';
marker[i++] = 0;
while (i<60)
while (i < 60)
marker[i++] = 32;
jpeg_write_marker (&cinfo, JPEG_APP0, marker, 60);
jpeg_write_marker(&cinfo, JPEG_APP0, marker, 60);
i=0;
while (i<60)
i = 0;
while (i < 60)
marker[i++] = 0;
jpeg_write_marker (&cinfo, JPEG_COM, marker, 60);
jpeg_write_marker(&cinfo, JPEG_COM, marker, 60);
rowstride= cinfo.image_width*cinfo.input_components;
rowstride = cinfo.image_width * cinfo.input_components;
for (y = 0; y < cinfo.image_height; y++) {
jpeg_write_scanlines(&cinfo, (JSAMPARRAY) &inBuffer, 1);
inBuffer += rowstride;
@@ -260,43 +268,43 @@ static void Compress_JPEG(int quality, unsigned char *outbuffer, unsigned char *
static void interlace(unsigned char *to, unsigned char *from, int width, int height)
{
int i, rowstride= width*3;
int i, rowstride = width * 3;
for (i=0; i<height; i++) {
if (i&1)
memcpy (&to[i*rowstride], &from[(i/2 + height/2)*rowstride], rowstride);
for (i = 0; i < height; i++) {
if (i & 1)
memcpy(&to[i * rowstride], &from[(i / 2 + height / 2) * rowstride], rowstride);
else
memcpy (&to[i*rowstride], &from[(i/2)*rowstride], rowstride);
memcpy(&to[i * rowstride], &from[(i / 2) * rowstride], rowstride);
}
}
static void deinterlace(int odd, unsigned char *to, unsigned char *from, int width, int height)
{
int i, rowstride= width*3;
int i, rowstride = width * 3;
for (i=0; i<height; i++) {
if ((i&1)==odd)
memcpy (&to[(i/2 + height/2)*rowstride], &from[i*rowstride], rowstride);
for (i = 0; i < height; i++) {
if ((i & 1) == odd)
memcpy(&to[(i / 2 + height / 2) * rowstride], &from[i * rowstride], rowstride);
else
memcpy (&to[(i/2)*rowstride], &from[i*rowstride], rowstride);
memcpy(&to[(i / 2) * rowstride], &from[i * rowstride], rowstride);
}
}
static int check_and_decode_jpeg(unsigned char *inbuf, unsigned char *outbuf, int width, int height, int bufsize)
{
/* JPEG's are always multiples of 16, extra is cropped out AVI's */
if ((width&0xF) || (height&0xF)) {
/* JPEG's are always multiples of 16, extra is cropped out AVI's */
if ((width & 0xF) || (height & 0xF)) {
int i, rrowstride, jrowstride;
int jwidth= PADUP(width, 16);
int jheight= PADUP(height, 16);
unsigned char *tmpbuf= MEM_mallocN(jwidth*jheight*3, "avi.check_and_decode_jpeg");
int ret= Decode_JPEG(inbuf, tmpbuf, jwidth, jheight, bufsize);
/* crop the tmpbuf into the real buffer */
rrowstride= width*3;
jrowstride= jwidth*3;
for (i=0; i<height; i++)
memcpy(&outbuf[i*rrowstride], &tmpbuf[i*jrowstride], rrowstride);
int jwidth = PADUP(width, 16);
int jheight = PADUP(height, 16);
unsigned char *tmpbuf = MEM_mallocN(jwidth * jheight * 3, "avi.check_and_decode_jpeg");
int ret = Decode_JPEG(inbuf, tmpbuf, jwidth, jheight, bufsize);
/* crop the tmpbuf into the real buffer */
rrowstride = width * 3;
jrowstride = jwidth * 3;
for (i = 0; i < height; i++)
memcpy(&outbuf[i * rrowstride], &tmpbuf[i * jrowstride], rrowstride);
MEM_freeN(tmpbuf);
return ret;
@@ -308,22 +316,22 @@ static int check_and_decode_jpeg(unsigned char *inbuf, unsigned char *outbuf, in
static void check_and_compress_jpeg(int quality, unsigned char *outbuf, unsigned char *inbuf, int width, int height, int bufsize)
{
/* JPEG's are always multiples of 16, extra is ignored in AVI's */
if ((width&0xF) || (height&0xF)) {
/* JPEG's are always multiples of 16, extra is ignored in AVI's */
if ((width & 0xF) || (height & 0xF)) {
int i, rrowstride, jrowstride;
int jwidth= PADUP(width, 16);
int jheight= PADUP(height, 16);
unsigned char *tmpbuf= MEM_mallocN(jwidth*jheight*3, "avi.check_and_compress_jpeg");
/* resize the realbuf into the tmpbuf */
rrowstride= width*3;
jrowstride= jwidth*3;
for (i=0; i<jheight; i++) {
if (i<height)
memcpy(&tmpbuf[i*jrowstride], &inbuf[i*rrowstride], rrowstride);
int jwidth = PADUP(width, 16);
int jheight = PADUP(height, 16);
unsigned char *tmpbuf = MEM_mallocN(jwidth * jheight * 3, "avi.check_and_compress_jpeg");
/* resize the realbuf into the tmpbuf */
rrowstride = width * 3;
jrowstride = jwidth * 3;
for (i = 0; i < jheight; i++) {
if (i < height)
memcpy(&tmpbuf[i * jrowstride], &inbuf[i * rrowstride], rrowstride);
else
memset(&tmpbuf[i*jrowstride], 0, rrowstride);
memset(&tmpbuf[i*jrowstride+rrowstride], 0, jrowstride-rrowstride);
memset(&tmpbuf[i * jrowstride], 0, rrowstride);
memset(&tmpbuf[i * jrowstride + rrowstride], 0, jrowstride - rrowstride);
}
Compress_JPEG(quality, outbuf, tmpbuf, jwidth, jheight, bufsize);
@@ -335,57 +343,57 @@ static void check_and_compress_jpeg(int quality, unsigned char *outbuf, unsigned
}
}
void *avi_converter_from_mjpeg (AviMovie *movie, int stream, unsigned char *buffer, int *size)
void *avi_converter_from_mjpeg(AviMovie *movie, int stream, unsigned char *buffer, int *size)
{
int deint;
unsigned char *buf;
(void)stream; /* unused */
buf= MEM_mallocN (movie->header->Height * movie->header->Width * 3, "avi.avi_converter_from_mjpeg 1");
buf = MEM_mallocN(movie->header->Height * movie->header->Width * 3, "avi.avi_converter_from_mjpeg 1");
deint= check_and_decode_jpeg(buffer, buf, movie->header->Width, movie->header->Height, *size);
deint = check_and_decode_jpeg(buffer, buf, movie->header->Width, movie->header->Height, *size);
MEM_freeN(buffer);
if (deint) {
buffer = MEM_mallocN (movie->header->Height * movie->header->Width * 3, "avi.avi_converter_from_mjpeg 2");
interlace (buffer, buf, movie->header->Width, movie->header->Height);
MEM_freeN (buf);
buffer = MEM_mallocN(movie->header->Height * movie->header->Width * 3, "avi.avi_converter_from_mjpeg 2");
interlace(buffer, buf, movie->header->Width, movie->header->Height);
MEM_freeN(buf);
buf= buffer;
buf = buffer;
}
return buf;
}
void *avi_converter_to_mjpeg (AviMovie *movie, int stream, unsigned char *buffer, int *size)
void *avi_converter_to_mjpeg(AviMovie *movie, int stream, unsigned char *buffer, int *size)
{
unsigned char *buf;
int bufsize= *size;
int bufsize = *size;
numbytes = 0;
*size= 0;
*size = 0;
buf = MEM_mallocN (movie->header->Height * movie->header->Width * 3, "avi.avi_converter_to_mjpeg 1");
buf = MEM_mallocN(movie->header->Height * movie->header->Width * 3, "avi.avi_converter_to_mjpeg 1");
if (!movie->interlace) {
check_and_compress_jpeg(movie->streams[stream].sh.Quality/100, buf, buffer, movie->header->Width, movie->header->Height, bufsize);
check_and_compress_jpeg(movie->streams[stream].sh.Quality / 100, buf, buffer, movie->header->Width, movie->header->Height, bufsize);
}
else {
deinterlace (movie->odd_fields, buf, buffer, movie->header->Width, movie->header->Height);
MEM_freeN (buffer);
deinterlace(movie->odd_fields, buf, buffer, movie->header->Width, movie->header->Height);
MEM_freeN(buffer);
buffer= buf;
buf= MEM_mallocN (movie->header->Height * movie->header->Width * 3, "avi.avi_converter_to_mjpeg 2");
buffer = buf;
buf = MEM_mallocN(movie->header->Height * movie->header->Width * 3, "avi.avi_converter_to_mjpeg 2");
check_and_compress_jpeg(movie->streams[stream].sh.Quality/100, buf, buffer, movie->header->Width, movie->header->Height/2, bufsize/2);
*size+= numbytes;
numbytes=0;
check_and_compress_jpeg(movie->streams[stream].sh.Quality/100, buf+*size, buffer+(movie->header->Height/2)*movie->header->Width*3, movie->header->Width, movie->header->Height/2, bufsize/2);
check_and_compress_jpeg(movie->streams[stream].sh.Quality / 100, buf, buffer, movie->header->Width, movie->header->Height / 2, bufsize / 2);
*size += numbytes;
numbytes = 0;
check_and_compress_jpeg(movie->streams[stream].sh.Quality / 100, buf + *size, buffer + (movie->header->Height / 2) * movie->header->Width * 3, movie->header->Width, movie->header->Height / 2, bufsize / 2);
}
*size += numbytes;
MEM_freeN (buffer);
MEM_freeN(buffer);
return buf;
}
@@ -405,23 +413,23 @@ static boolean jpegmemdestmgr_empty_output_buffer(j_compress_ptr cinfo)
static void jpegmemdestmgr_term_destination(j_compress_ptr cinfo)
{
numbytes-= cinfo->dest->free_in_buffer;
numbytes -= cinfo->dest->free_in_buffer;
MEM_freeN(cinfo->dest);
}
static void jpegmemdestmgr_build(j_compress_ptr cinfo, unsigned char *buffer, int bufsize)
{
cinfo->dest= MEM_mallocN(sizeof(*(cinfo->dest)), "avi.jpegmemdestmgr_build");
cinfo->dest = MEM_mallocN(sizeof(*(cinfo->dest)), "avi.jpegmemdestmgr_build");
cinfo->dest->init_destination= jpegmemdestmgr_init_destination;
cinfo->dest->empty_output_buffer= jpegmemdestmgr_empty_output_buffer;
cinfo->dest->term_destination= jpegmemdestmgr_term_destination;
cinfo->dest->init_destination = jpegmemdestmgr_init_destination;
cinfo->dest->empty_output_buffer = jpegmemdestmgr_empty_output_buffer;
cinfo->dest->term_destination = jpegmemdestmgr_term_destination;
cinfo->dest->next_output_byte= buffer;
cinfo->dest->free_in_buffer= bufsize;
cinfo->dest->next_output_byte = buffer;
cinfo->dest->free_in_buffer = bufsize;
numbytes= bufsize;
numbytes = bufsize;
}
/* Decompression from memory */
@@ -433,48 +441,48 @@ static void jpegmemsrcmgr_init_source(j_decompress_ptr dinfo)
static boolean jpegmemsrcmgr_fill_input_buffer(j_decompress_ptr dinfo)
{
unsigned char *buf= (unsigned char*) dinfo->src->next_input_byte-2;
unsigned char *buf = (unsigned char *) dinfo->src->next_input_byte - 2;
/* if we get called, must have run out of data */
/* if we get called, must have run out of data */
WARNMS(dinfo, JWRN_JPEG_EOF);
buf[0]= (JOCTET) 0xFF;
buf[1]= (JOCTET) JPEG_EOI;
buf[0] = (JOCTET) 0xFF;
buf[1] = (JOCTET) JPEG_EOI;
dinfo->src->next_input_byte= buf;
dinfo->src->bytes_in_buffer= 2;
dinfo->src->next_input_byte = buf;
dinfo->src->bytes_in_buffer = 2;
return TRUE;
}
static void jpegmemsrcmgr_skip_input_data(j_decompress_ptr dinfo, long skipcnt)
{
if (dinfo->src->bytes_in_buffer<skipcnt)
skipcnt= dinfo->src->bytes_in_buffer;
if (dinfo->src->bytes_in_buffer < skipcnt)
skipcnt = dinfo->src->bytes_in_buffer;
dinfo->src->next_input_byte+= skipcnt;
dinfo->src->bytes_in_buffer-= skipcnt;
dinfo->src->next_input_byte += skipcnt;
dinfo->src->bytes_in_buffer -= skipcnt;
}
static void jpegmemsrcmgr_term_source(j_decompress_ptr dinfo)
{
numbytes-= dinfo->src->bytes_in_buffer;
numbytes -= dinfo->src->bytes_in_buffer;
MEM_freeN(dinfo->src);
}
static void jpegmemsrcmgr_build(j_decompress_ptr dinfo, unsigned char *buffer, int bufsize)
{
dinfo->src= MEM_mallocN(sizeof(*(dinfo->src)), "avi.jpegmemsrcmgr_build");
dinfo->src = MEM_mallocN(sizeof(*(dinfo->src)), "avi.jpegmemsrcmgr_build");
dinfo->src->init_source= jpegmemsrcmgr_init_source;
dinfo->src->fill_input_buffer= jpegmemsrcmgr_fill_input_buffer;
dinfo->src->skip_input_data= jpegmemsrcmgr_skip_input_data;
dinfo->src->resync_to_restart= jpeg_resync_to_restart;
dinfo->src->term_source= jpegmemsrcmgr_term_source;
dinfo->src->init_source = jpegmemsrcmgr_init_source;
dinfo->src->fill_input_buffer = jpegmemsrcmgr_fill_input_buffer;
dinfo->src->skip_input_data = jpegmemsrcmgr_skip_input_data;
dinfo->src->resync_to_restart = jpeg_resync_to_restart;
dinfo->src->term_source = jpegmemsrcmgr_term_source;
dinfo->src->bytes_in_buffer= bufsize;
dinfo->src->next_input_byte= buffer;
dinfo->src->bytes_in_buffer = bufsize;
dinfo->src->next_input_byte = buffer;
numbytes= bufsize;
numbytes = bufsize;
}

132
source/blender/avi/intern/options.c
View File

@@ -54,78 +54,78 @@ AviError AVI_set_compress_option(AviMovie *movie, int option_type, int stream, A
return AVI_ERROR_OPTION;
switch (option_type) {
case AVI_OPTION_TYPE_MAIN:
switch (option) {
case AVI_OPTION_WIDTH:
movie->header->Width = *((int *) opt_data);
movie->header->SuggestedBufferSize = movie->header->Width*movie->header->Height*3;
case AVI_OPTION_TYPE_MAIN:
switch (option) {
case AVI_OPTION_WIDTH:
movie->header->Width = *((int *) opt_data);
movie->header->SuggestedBufferSize = movie->header->Width * movie->header->Height * 3;
for (i = 0; i < movie->header->Streams; i++) {
if (avi_get_format_type(movie->streams[i].format) == FCC("vids")) {
((AviBitmapInfoHeader *) movie->streams[i].sf)->Width = *((int *) opt_data);
movie->streams[i].sh.SuggestedBufferSize = movie->header->SuggestedBufferSize;
movie->streams[i].sh.right = *((int *) opt_data);
((AviBitmapInfoHeader *) movie->streams[i].sf)->SizeImage = movie->header->SuggestedBufferSize;
fseek(movie->fp, movie->offset_table[1 + i * 2 + 1], SEEK_SET);
awrite(movie, movie->streams[i].sf, 1, movie->streams[i].sf_size, movie->fp, AVI_BITMAPH);
}
}
break;
case AVI_OPTION_HEIGHT:
movie->header->Height = *((int *) opt_data);
movie->header->SuggestedBufferSize = movie->header->Width * movie->header->Height * 3;
for (i = 0; i < movie->header->Streams; i++) {
if (avi_get_format_type(movie->streams[i].format) == FCC("vids")) {
((AviBitmapInfoHeader *) movie->streams[i].sf)->Height = *((int *) opt_data);
movie->streams[i].sh.SuggestedBufferSize = movie->header->SuggestedBufferSize;
movie->streams[i].sh.bottom = *((int *) opt_data);
((AviBitmapInfoHeader *) movie->streams[i].sf)->SizeImage = movie->header->SuggestedBufferSize;
fseek(movie->fp, movie->offset_table[1 + i * 2 + 1], SEEK_SET);
awrite(movie, movie->streams[i].sf, 1, movie->streams[i].sf_size, movie->fp, AVI_BITMAPH);
}
}
break;
case AVI_OPTION_QUALITY:
for (i = 0; i < movie->header->Streams; i++) {
if (avi_get_format_type(movie->streams[i].format) == FCC("vids")) {
movie->streams[i].sh.Quality = (*((int *) opt_data)) * 100;
fseek(movie->fp, movie->offset_table[1 + i * 2 + 1], SEEK_SET);
awrite(movie, movie->streams[i].sf, 1, movie->streams[i].sf_size, movie->fp, AVI_BITMAPH);
}
}
break;
case AVI_OPTION_FRAMERATE:
useconds = (int)(1000000 / (*((double *) opt_data)));
if (useconds)
movie->header->MicroSecPerFrame = useconds;
for (i = 0; i < movie->header->Streams; i++) {
if (avi_get_format_type(movie->streams[i].format) == FCC("vids")) {
movie->streams[i].sh.Scale = movie->header->MicroSecPerFrame;
fseek(movie->fp, movie->offset_table[1 + i * 2 + 1], SEEK_SET);
awrite(movie, movie->streams[i].sf, 1, movie->streams[i].sf_size, movie->fp, AVI_BITMAPH);
}
}
for (i=0; i < movie->header->Streams; i++) {
if (avi_get_format_type(movie->streams[i].format) == FCC("vids")) {
((AviBitmapInfoHeader *) movie->streams[i].sf)->Width = *((int *) opt_data);
movie->streams[i].sh.SuggestedBufferSize = movie->header->SuggestedBufferSize;
movie->streams[i].sh.right = *((int *) opt_data);
((AviBitmapInfoHeader *) movie->streams[i].sf)->SizeImage = movie->header->SuggestedBufferSize;
fseek (movie->fp, movie->offset_table[1+i*2+1], SEEK_SET);
awrite (movie, movie->streams[i].sf, 1, movie->streams[i].sf_size, movie->fp, AVI_BITMAPH);
}
}
fseek(movie->fp, movie->offset_table[0], SEEK_SET);
awrite(movie, movie->header, 1, sizeof(AviMainHeader), movie->fp, AVI_MAINH);
break;
case AVI_OPTION_HEIGHT:
movie->header->Height = *((int *) opt_data);
movie->header->SuggestedBufferSize = movie->header->Width*movie->header->Height*3;
for (i=0; i < movie->header->Streams; i++) {
if (avi_get_format_type(movie->streams[i].format) == FCC("vids")) {
((AviBitmapInfoHeader *) movie->streams[i].sf)->Height = *((int *) opt_data);
movie->streams[i].sh.SuggestedBufferSize = movie->header->SuggestedBufferSize;
movie->streams[i].sh.bottom = *((int *) opt_data);
((AviBitmapInfoHeader *) movie->streams[i].sf)->SizeImage = movie->header->SuggestedBufferSize;
fseek (movie->fp, movie->offset_table[1+i*2+1], SEEK_SET);
awrite (movie, movie->streams[i].sf, 1, movie->streams[i].sf_size, movie->fp, AVI_BITMAPH);
}
}
case AVI_OPTION_TYPE_STRH:
break;
case AVI_OPTION_QUALITY:
for (i=0; i < movie->header->Streams; i++) {
if (avi_get_format_type(movie->streams[i].format) == FCC("vids")) {
movie->streams[i].sh.Quality = (*((int *) opt_data))*100;
fseek (movie->fp, movie->offset_table[1+i*2+1], SEEK_SET);
awrite (movie, movie->streams[i].sf, 1, movie->streams[i].sf_size, movie->fp, AVI_BITMAPH);
}
}
case AVI_OPTION_TYPE_STRF:
break;
default:
return AVI_ERROR_OPTION;
break;
case AVI_OPTION_FRAMERATE:
useconds = (int)(1000000/(*((double *) opt_data)));
if (useconds)
movie->header->MicroSecPerFrame = useconds;
for (i=0; i < movie->header->Streams; i++) {
if (avi_get_format_type(movie->streams[i].format) == FCC("vids")) {
movie->streams[i].sh.Scale = movie->header->MicroSecPerFrame;
fseek (movie->fp, movie->offset_table[1+i*2+1], SEEK_SET);
awrite (movie, movie->streams[i].sf, 1, movie->streams[i].sf_size, movie->fp, AVI_BITMAPH);
}
}
}
fseek (movie->fp, movie->offset_table[0], SEEK_SET);
awrite (movie, movie->header, 1, sizeof(AviMainHeader), movie->fp, AVI_MAINH);
break;
case AVI_OPTION_TYPE_STRH:
break;
case AVI_OPTION_TYPE_STRF:
break;
default:
return AVI_ERROR_OPTION;
break;
}
return AVI_ERROR_NONE;

34
source/blender/avi/intern/rgb32.c
View File

@@ -39,33 +39,33 @@
#include "MEM_guardedalloc.h"
#include "rgb32.h"
void *avi_converter_from_rgb32 (AviMovie *movie, int stream, unsigned char *buffer, int *size)
void *avi_converter_from_rgb32(AviMovie *movie, int stream, unsigned char *buffer, int *size)
{
int y, x, rowstridea, rowstrideb;
unsigned char *buf;
(void)stream; /* unused */
buf = MEM_mallocN (movie->header->Height * movie->header->Width * 3, "fromrgb32buf");
buf = MEM_mallocN(movie->header->Height * movie->header->Width * 3, "fromrgb32buf");
*size = movie->header->Height * movie->header->Width * 3;
rowstridea = movie->header->Width*3;
rowstrideb = movie->header->Width*4;
rowstridea = movie->header->Width * 3;
rowstrideb = movie->header->Width * 4;
for (y=0; y < movie->header->Height; y++) {
for (x=0; x < movie->header->Width; x++) {
buf[y*rowstridea + x*3 + 0] = buffer[y*rowstrideb + x*4 + 3];
buf[y*rowstridea + x*3 + 1] = buffer[y*rowstrideb + x*4 + 2];
buf[y*rowstridea + x*3 + 2] = buffer[y*rowstrideb + x*4 + 1];
for (y = 0; y < movie->header->Height; y++) {
for (x = 0; x < movie->header->Width; x++) {
buf[y * rowstridea + x * 3 + 0] = buffer[y * rowstrideb + x * 4 + 3];
buf[y * rowstridea + x * 3 + 1] = buffer[y * rowstrideb + x * 4 + 2];
buf[y * rowstridea + x * 3 + 2] = buffer[y * rowstrideb + x * 4 + 1];
}
}
MEM_freeN (buffer);
MEM_freeN(buffer);
return buf;
}
void *avi_converter_to_rgb32 (AviMovie *movie, int stream, unsigned char *buffer, int *size)
void *avi_converter_to_rgb32(AviMovie *movie, int stream, unsigned char *buffer, int *size)
{
int i;
unsigned char *buf;
@@ -73,20 +73,20 @@ void *avi_converter_to_rgb32 (AviMovie *movie, int stream, unsigned char *buffer
(void)stream; /* unused */
buf= MEM_mallocN (movie->header->Height * movie->header->Width * 4, "torgb32buf");
*size= movie->header->Height * movie->header->Width * 4;
buf = MEM_mallocN(movie->header->Height * movie->header->Width * 4, "torgb32buf");
*size = movie->header->Height * movie->header->Width * 4;
memset(buf, 255, *size);
to= buf; from= buffer;
i=movie->header->Height*movie->header->Width;
to = buf; from = buffer;
i = movie->header->Height * movie->header->Width;
while (i--) {
memcpy(to, from, 3);
to+=4; from+=3;
to += 4; from += 3;
}
MEM_freeN (buffer);
MEM_freeN(buffer);
return buf;
}