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

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

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

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

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

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

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

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

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

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

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

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