backup
/
gps
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
gps/GPSResources/tcpmpVerOld/camera/tiff.c

656 lines
13 KiB
C
Executable File
Raw Blame History

/*****************************************************************************
*
* This program is free software ; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* $Id: tiff.c 313 2005-10-29 15:15:47Z picard $
*
* The Core Pocket Media Player
* Copyright (c) 2004-2005 Gabor Kovacs
*
****************************************************************************/
#include "../common/common.h"
#include "../common/zlib/zlib.h"
#include "tiff.h"
DECLARE_BITINIT
DECLARE_BITLOAD
typedef struct tiff
{
codec Codec;
buffer Buffer;
bool_t ErrorShowed;
bool_t BigEndian;
const uint8_t* Ptr;
int BitCount;
int BytesPerRow;
int BytesPerRow2;
int Planar;
int Channels;
int Left;
bool_t Reverse;
} tiff;
static int UpdateInput(tiff* p)
{
p->ErrorShowed = 0;
BufferClear(&p->Buffer);
if (p->Codec.In.Format.Type == PACKET_VIDEO)
{
PacketFormatCopy(&p->Codec.Out.Format,&p->Codec.In.Format);
p->Codec.Out.Format.Format.Video.Pixel.Flags = PF_RGB;
p->Codec.Out.Format.Format.Video.Pixel.BitCount = 24;
p->Codec.Out.Format.Format.Video.Pixel.BitMask[0] = 0xFF;
p->Codec.Out.Format.Format.Video.Pixel.BitMask[1] = 0xFF00;
p->Codec.Out.Format.Format.Video.Pixel.BitMask[2] = 0xFF0000;
DefaultPitch(&p->Codec.Out.Format.Format.Video);
}
return ERR_NONE;
}
static NOINLINE int Read32(tiff* p)
{
int v;
if (p->BigEndian)
v = LOAD32BE(p->Ptr);
else
v = LOAD32LE(p->Ptr);
p->Ptr += 4;
return v;
}
static NOINLINE int Read16(tiff* p)
{
int v;
if (p->BigEndian)
v = LOAD16BE(p->Ptr);
else
v = LOAD16LE(p->Ptr);
p->Ptr += 2;
return v;
}
static NOINLINE int ReadVal(tiff* p,int Type)
{
switch (Type)
{
case 1: return *(p->Ptr++);
case 3: return Read16(p);
case 4: return Read32(p);
}
return 0;
}
static NOINLINE int NotSupported(tiff* p)
{
if (!p->ErrorShowed)
{
p->ErrorShowed = 1;
ShowError(p->Codec.Node.Class,TIFF_ID,TIFF_NOT_SUPPORTED);
}
return ERR_NOT_SUPPORTED;
}
static NOINLINE void Write(tiff* p,const uint8_t* Data,int Size)
{
int n,i,j;
if (p->Planar == 1)
{
while (Size>0)
{
if (!p->Left)
p->Left = p->BytesPerRow;
n = min(p->Left,Size);
Size -= n;
p->Left -= n;
switch (p->BitCount)
{
case 1:
j = n*8;
if (!p->Left)
j -= 8*p->BytesPerRow - p->BytesPerRow2;
for (i=0;i<j;++i)
p->Buffer.Data[p->Buffer.WritePos++] = (uint8_t)((Data[i>>3] >> (7-(i&7))) & 1);
break;
case 2:
j = n*4;
if (!p->Left)
j -= 4*p->BytesPerRow - p->BytesPerRow2;
for (i=0;i<j;++i)
p->Buffer.Data[p->Buffer.WritePos++] = (uint8_t)((Data[i>>2] >> (6-2*(i&3))) & 3);
break;
case 4:
j = n*2;
if (!p->Left)
j -= 2*p->BytesPerRow - p->BytesPerRow2;
for (i=0;i<j;++i)
p->Buffer.Data[p->Buffer.WritePos++] = (uint8_t)((Data[i>>1] >> (4-4*(i&1))) & 15);
break;
default:
memcpy(p->Buffer.Data + p->Buffer.WritePos,Data,n);
p->Buffer.WritePos += n;
break;
}
Data += n;
if (!p->Left)
p->Buffer.WritePos += p->Codec.Out.Format.Format.Video.Pitch - p->BytesPerRow2;
}
}
else
{
while (Size>0)
{
if (!p->Left)
p->Left = p->BytesPerRow;
n = min(p->Left,Size);
Size -= n;
p->Left -= n;
while (--n>=0)
{
p->Buffer.Data[p->Buffer.WritePos] = *(++Data);
p->Buffer.WritePos += p->Channels;
}
if (!p->Left)
p->Buffer.WritePos += p->Codec.Out.Format.Format.Video.Pitch - p->BytesPerRow*p->Channels;
}
}
}
static void Inflate(tiff *p,const uint8_t* Data,int Size,int Total)
{
int i,n;
z_stream Inflate;
uint8_t Buffer[4096];
memset(&Inflate,0,sizeof(Inflate));
if (inflateInit2(&Inflate, MAX_WBITS) == Z_OK)
{
Inflate.next_in = (Bytef*)Data;
Inflate.avail_in = Size;
do
{
Inflate.next_out = Buffer;
Inflate.avail_out = sizeof(Buffer);
i = inflate(&Inflate, Z_SYNC_FLUSH);
n = sizeof(Buffer) - Inflate.avail_out;
if (n>Total)
n=Total;
Write(p,Buffer,n);
Total -= n;
} while (i>=0 && i!=Z_STREAM_END && Total>0);
inflateEnd(&Inflate);
}
}
/*
static void Fax3(tiff *p,const uint8_t* Data,int Size,int Total)
{
//todo
}
*/
static void LZW(tiff *p,const uint8_t* Data,int Size)
{
bitstream bs;
uint16_t Prefix[4096];
uint8_t Suffix[4096];
uint8_t Stack[4096];
uint8_t FirstChar;
int ClearCode = 256;
int EOICode = ClearCode+1;
int FreeCode = ClearCode+2;
int OldCode = -1;
int CodeSize = 9;
int i;
for (i=0;i<ClearCode;++i)
Suffix[i] = (uint8_t)i;
FirstChar = 0;
bitinit(&bs,Data,Size);
while (!biteof(&bs))
{
uint8_t* StackPtr;
int Code;
bitload(&bs);
Code = bitget(&bs,CodeSize);
if (Code == EOICode)
break;
if (Code == ClearCode)
{
CodeSize = 9;
FreeCode = ClearCode + 2;
OldCode = -1;
continue;
}
if (Code > FreeCode)
break;
if (OldCode<0)
{
FirstChar = Suffix[Code];
Write(p,&FirstChar,1);
OldCode = Code;
continue;
}
StackPtr = Stack+sizeof(Stack);
i = Code;
if (i == FreeCode)
{
*(--StackPtr) = FirstChar;
i = OldCode;
}
while (i>ClearCode)
{
*(--StackPtr) = Suffix[i];
i = Prefix[i];
}
FirstChar = Suffix[i];
*(--StackPtr) = FirstChar;
Prefix[FreeCode] = (uint16_t)OldCode;
Suffix[FreeCode] = FirstChar;
if (FreeCode < 4096) ++FreeCode;
if (CodeSize<12 && FreeCode == (1<<CodeSize)-1)
++CodeSize;
OldCode = Code;
Write(p,StackPtr,Stack+sizeof(Stack)-StackPtr);
}
}
static int Process(tiff* p, const packet* Packet, const flowstate* State)
{
int n,Compress;
size_t IFD;
int RowPerStrip;
video Video;
const uint8_t *Strips;
rgb Pal[256];
int StripsType,StripsLen;
int Bits[3];
int BitCount;
int h,ch;
int i,j,k;
if (!Packet)
return ERR_NEED_MORE_DATA;
p->Ptr = Packet->Data[0];
if (Packet->Length<8)
return ERR_INVALID_DATA;
if (p->Ptr[0]=='M' && p->Ptr[1]=='M')
p->BigEndian = 1;
else
if (p->Ptr[0]=='I' && p->Ptr[1]=='I')
p->BigEndian = 0;
else
return ERR_INVALID_DATA;
p->Ptr += 2;
if (Read16(p) != 42)
return ERR_INVALID_DATA;
IFD = Read32(p);
if (IFD<8 || IFD+2+4 >= Packet->Length)
return ERR_INVALID_DATA;
p->Reverse = 0;
RowPerStrip = MAX_INT;
memset(&Video,0,sizeof(Video));
p->Planar = 1;
p->Channels = 0;
Compress = 1;
Strips = NULL;
StripsType = 0;
StripsLen = 0;
BitCount = 0;
Video.Pixel.Flags = PF_RGB;
Video.Aspect = ASPECT_ONE; //todo
for (i=0;i<256;++i)
Pal[i].v = CRGB(i,i,i);
p->Ptr = (const uint8_t*)Packet->Data[0]+IFD;
n = Read16(p);
while (--n>=0)
{
const uint8_t* Save = p->Ptr+12;
int Tag = Read16(p);
int Type = Read16(p);
int Len = Read32(p);
size_t Pos = Read32(p);
switch (Type)
{
case 1:
case 2: i=1; break;
case 3: i=2; break;
case 4: i=4; break;
case 5: i=8; break;
default: i=0; break;
}
i *= Len;
if (i<=4)
p->Ptr -= 4;
else
{
if (Pos > Packet->Length-i)
continue;
p->Ptr = (const uint8_t*)Packet->Data[0]+Pos;
}
// read integer
i = 0;
if (Len==1)
switch (Type)
{
case 1: i=p->Ptr[0]; break;
case 3: i=Read16(p); p->Ptr-=2; break;
case 4: i=Read32(p); p->Ptr-=4; break;
}
switch (Tag)
{
case 0x100:
Video.Width = i;
break;
case 0x101:
Video.Height = i;
break;
case 0x102:
if (Len>3)
return NotSupported(p);
p->Channels = Len;
BitCount = 0;
for (i=0;i<Len;++i)
{
Bits[i] = ReadVal(p,Type);
Video.Pixel.BitMask[i] = ((1 << Bits[i])-1) << BitCount;
BitCount += Bits[i];
}
p->BitCount = BitCount;
Video.Pixel.BitCount = BitCount;
if (Video.Pixel.BitCount==1 ||
Video.Pixel.BitCount==2 ||
Video.Pixel.BitCount==4)
{
int n = 1<<BitCount;
for (i=0;i<n;++i)
{
int j = (255*i)/(n-1);
Pal[i].v = CRGB(j,j,j);
}
Video.Pixel.BitCount=8;
}
if (Video.Pixel.BitCount & 7) // only 1,2,4,8,16,24,32 bitdepth supported
return NotSupported(p);
break;
case 0x103:
Compress = i;
break;
case 0x106:
switch (i)
{
case 0: // invert grayscale
Video.Pixel.Flags = PF_GRAYSCALE|PF_PALETTE;
for (i=0;i<256;++i)
Pal[i].v ^= CRGB(255,255,255);
break;
case 1: // grayscale
Video.Pixel.Flags = PF_GRAYSCALE|PF_PALETTE;
break;
case 2: // rgb
Video.Pixel.Flags = PF_RGB;
break;
case 3: // palette
Video.Pixel.Flags = PF_PALETTE;
break;
}
break;
case 0x10A: // fill order
p->Reverse = i==2;
break;
case 0x111: // strip offsets
Strips = p->Ptr;
StripsType = Type;
StripsLen = Len;
break;
case 0x116:
RowPerStrip = i;
break;
case 0x11C:
p->Planar = i;
if (i != 1 && BitCount != p->Channels*8) // only 24,32 supported
return NotSupported(p);
break;
case 0x15B:
// jpeg tables
break;
case 0x140:
Video.Pixel.Flags = PF_PALETTE;
k = 1<<BitCount;
if (Len >= 3*k)
for (j=0;j<3;++j)
for (i=0;i<k;++i)
Pal[i].ch[j] = (uint8_t)(ReadVal(p,Type)>>8);
break;
}
p->Ptr = Save;
}
if (!Strips || !Video.Width || !Video.Height || !p->Channels)
return ERR_INVALID_DATA;
if ((Video.Pixel.Flags & PF_PALETTE) && (p->Channels!=1 || Video.Pixel.BitCount!=8))
return NotSupported(p);
DefaultPitch(&Video);
if (!EqVideo(&Video,&p->Codec.Out.Format.Format.Video))
{
if ((Video.Pixel.Flags & PF_PALETTE) && PacketFormatExtra(&p->Codec.Out.Format,sizeof(Pal)))
{
memcpy(p->Codec.Out.Format.Extra,Pal,sizeof(Pal));
Video.Pixel.Palette = p->Codec.Out.Format.Extra;
}
p->Codec.In.Format.Format.Video.Width = Video.Width;
p->Codec.In.Format.Format.Video.Height = Video.Height;
p->Codec.Out.Format.Format.Video = Video;
ConnectionUpdate(&p->Codec.Node,CODEC_OUTPUT,p->Codec.Out.Pin.Node,p->Codec.Out.Pin.No);
}
BufferDrop(&p->Buffer);
if (!BufferAlloc(&p->Buffer,Video.Pitch*Video.Height,4096))
return ERR_OUT_OF_MEMORY;
p->Ptr = Strips;
p->Left = 0;
ch = 0;
h = Video.Height;
for (n=0;n<StripsLen && h>0;++n)
{
int Len,Pos,y;
const uint8_t* Src;
Pos = ReadVal(p,StripsType);
Len = Packet->Length - Pos;
if (Len <= 0)
break;
Src = (const uint8_t*)Packet->Data[0]+Pos;
y = min(RowPerStrip,h);
h -= y;
if (p->Planar == 1)
{
p->BytesPerRow = ((BitCount*Video.Width + 7) >> 3);
p->BytesPerRow2 = ((Video.Pixel.BitCount*Video.Width + 7) >> 3);
}
else
p->BytesPerRow2 = p->BytesPerRow = ((Bits[ch] * Video.Width + 7) >> 3);
switch (Compress)
{
case 1:
Write(p,Src,p->BytesPerRow*y);
break;
// case 2: //rle
// break;
// case 3: //fax3
// Fax3(p,Src,Len,p->BytesPerRow*y);
// break;
// case 4: //fax4
// break;
case 5:
LZW(p,Src,Len);
break;
case 8:
case 32946: //zlib
Inflate(p,Src,Len,p->BytesPerRow*y);
break;
default:
return NotSupported(p);
}
if (p->Planar != 1 && h==0)
{
// next plane
if (ch == p->Channels) break;
h = Video.Height;
p->Left = 0;
p->Buffer.WritePos = ++ch;
}
}
p->Codec.Packet.RefTime = Packet->RefTime;
p->Codec.Packet.Length = p->Buffer.WritePos;
p->Codec.Packet.Data[0] = p->Buffer.Data;
return ERR_NONE;
}
static int Resend(tiff* p)
{
int Result = ERR_INVALID_DATA;
if (p->Buffer.WritePos)
{
packet Packet;
flowstate State;
State.CurrTime = TIME_RESEND;
State.DropLevel = 0;
memset(&Packet,0,sizeof(Packet));
Packet.RefTime = TIME_UNKNOWN;
Packet.Length = p->Buffer.WritePos;
Packet.Data[0] = p->Buffer.Data;
Result = p->Codec.Out.Process(p->Codec.Out.Pin.Node,&Packet,&State);
}
return Result;
}
static int Flush(tiff* p)
{
BufferDrop(&p->Buffer);
return ERR_NONE;
}
static int Create(tiff* p)
{
p->Codec.Process = (packetprocess)Process;
p->Codec.UpdateInput = (nodefunc)UpdateInput;
p->Codec.ReSend = (nodefunc)Resend;
p->Codec.Flush = (nodefunc)Flush;
return ERR_NONE;
}
static const nodedef TIFF =
{
sizeof(tiff),
TIFF_ID,
CODEC_CLASS,
PRI_DEFAULT,
(nodecreate)Create,
NULL,
};
//-------------------------------------------------------------------------------------------
static const nodedef TIFFFile =
{
0, // parent size
TIFF_FILE_ID,
RAWIMAGE_CLASS,
PRI_DEFAULT,
};
//---------------------------------------------------------------------------------------------
void TIFF_Init()
{
NodeRegisterClass(&TIFF);
NodeRegisterClass(&TIFFFile);
}
void TIFF_Done()
{
NodeUnRegisterClass(TIFF_ID);
NodeUnRegisterClass(TIFF_FILE_ID);
}
Reference in New Issue View Git Blame Copy Permalink