/*****************************************************************************
 *
 * 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: avi.c 607 2006-01-22 20:58:29Z picard $
 *
 * The Core Pocket Media Player
 * Copyright (c) 2004-2005 Gabor Kovacs
 *
 ****************************************************************************/

#include "../common/common.h"
#include "avi.h"

#define INDEXSTEP	512

#define AVI_INDEX_OF_INDEXES	0x00
#define AVI_INDEX_OF_CHUNKS		0x01
#define AVI_INDEX_KEY			0x80000000

typedef struct aviindex
{
	int32_t Id;
	int8_t Flags[4];
	int32_t Pos;
	int32_t Length;
} aviindex;

typedef struct avisuperindex
{
	int Offset;
	int Size;
	int StartTime;
	int EndTime;
	int LastData;

} avisuperindex;

typedef struct avistdindex
{
	uint32_t FourCC;
	int Size;
	int16_t LongsPerEntry;
	int8_t IndexSubType;
	int8_t IndexType;
	int Count;
	int ChunkId;
	int OffsetLow;
	int OffsetHigh;
	int Reserved;

} avistdindex;

typedef struct avistream
{
	format_stream Stream;
	
	int* Index;			// mediatime
	bool_t ByteRate;
	int RefStart;
	int MediaTime;
	int NewMediaTime;	// after seek (if seek successed)
	fraction64 MediaRate; // byterate or packetrate
	int SampleSize;
	int MaxPacket;
	int Length;
	int SuperIndexCount;
	avisuperindex* SuperIndex; //opendml index
	int PrevKey;
	int PrevMediaTime;
	int PrevKeyBuffer;

	filepos_t OffsetMin;
	filepos_t OffsetMax;
	int* ZeroChunkPos;
	array ZeroChunk;
	int LastPos;

} avistream;

typedef struct avi
{
	format_base Format;

	int FramePeriod;
	int ByteRate;
	bool_t ErrorIndex;
	bool_t UnLimited;
	bool_t CheckForZero;
	bool_t FoundStdIndex;

	int DataPos;
	int DataEnd;

	// stream header and format loading
	int HeadType;
	avistream* LastStream;

	int VideoHandler;
	int VideoFrames;
	fraction VideoFPS;
	int VideoStart;

	fraction AudioRate;
	int AudioLength;
	int AudioStart;
	int AudioSampleSize;
	
	int IndexAdjustPos;
	int IndexCount;
	int IndexPos;
	int IndexReaded;
	int IndexBufferNo;
	block IndexBuffer;

	char NameChar[256];

	int FoundTotal;
	int FoundAtEnd[8];
	int FoundLastPos[8];

} avi;

#define ALIGN2(x) (((x)+1)&~1)
#define ISDIGIT(x) ((x)>='0' && (x)<='9')
#define STREAMNO(x) ((((x) & 255)-'0')*10 + ((((x) >> 8) & 255)-'0'))
#define ISDATA(x) (ISDIGIT((x) & 255) && ISDIGIT(((x) >> 8) & 255))
#define ISIDX(x) (ISDIGIT(((x) >> 16) & 255) && ISDIGIT(((x) >> 24) & 255) && ((x) & 255)=='i' && (((x) >> 8) & 255)=='x')
#define IDXNO(x) (((((x) >> 16) & 255)-'0')*10 + ((((x) >> 24) & 255)-'0'))

static void Done(avi* p)
{
	FreeBlock(&p->IndexBuffer);
}

#define CHECKINDEX	16384

static NOINLINE int Load32LE(const uint8_t* i) { return LOAD32LE(i); }

static void PreCheckIndexODML(avi* p,avistream* Stream)
{
	int k;
	array Array = {NULL};
	avistdindex StdIndex;
	stream* Input = p->Format.Reader->Input;
	filepos_t Save = Input->Seek(Input,0,SEEK_CUR);
	if (Save>=0 && Input->Seek(Input,Stream->SuperIndex[0].Offset,SEEK_SET)>=0)
	{
		if (Input->Read(Input,&StdIndex,sizeof(StdIndex)) == sizeof(StdIndex) &&
			StdIndex.IndexType == AVI_INDEX_OF_CHUNKS &&
			StdIndex.LongsPerEntry == 2)
		{
			if (StdIndex.Count > 1024)
				StdIndex.Count = 1024;

			if (ArrayAppend(&Array,NULL,8*StdIndex.Count,1024))
			{
				if (Input->Read(Input,ARRAYBEGIN(Array,int32_t),8*StdIndex.Count) == 8*StdIndex.Count)
				{
					for (k=0;k<StdIndex.Count;++k)
						if ((ARRAYBEGIN(Array,int32_t)[k*2+1] & ~AVI_INDEX_KEY)==0)
						{
							p->CheckForZero = 1;
							break;
						}
				}
				ArrayClear(&Array);
			}
		}
		Input->Seek(Input,Save,SEEK_SET);
	}
}

static void PreCheckIndex(avi* p)
{
	block Buffer;
	if (AllocBlock(CHECKINDEX,&Buffer,0,HEAP_ANY))
	{
		format_reader* Reader = p->Format.Reader;
		filepos_t Save = Reader->Input->Seek(Reader->Input,0,SEEK_CUR);
		if (Save>=0 && Reader->Input->Seek(Reader->Input,-CHECKINDEX,SEEK_END)>=0)
		{
			if (Reader->Input->ReadBlock(Reader->Input,&Buffer,0,CHECKINDEX)==CHECKINDEX)
			{
				int Type = 0;
				int LastNo;
				int No = 24;
				const uint8_t* i = Buffer.Ptr+CHECKINDEX-12;

				while (--i>=Buffer.Ptr+16)
				{
					if (p->NameChar[*i])
					{
						Type |= *i << No;
						No -= 8;
						if (No<0)
						{
							if (Type == FOURCCLE('J','U','N','K') && ISDATA(Load32LE(i-16)))
							{
								i -= 16;
								p->FoundStdIndex = 1;
								break;
							}
							if (ISDATA(Type) && (Load32LE(i+4) & ~0x10)==0)
							{
								p->FoundStdIndex = 1;
								break;
							}
							Type <<= 8;
							No += 8;
						}
					}
					else
					{
						Type = 0;
						No = 24;
					}
				}

				LastNo = -1;
				for (;i>=Buffer.Ptr+16;i-=16)
				{
					if (Load32LE(i-8) == FOURCCLE('i','d','x','1'))
						break;

					Type = Load32LE(i);
					if (ISDATA(Type))
					{
						int Pos = Load32LE(i+8);
						int No = STREAMNO(Type);
						if (No >= 0 && No < 8)
						{
							if (No != LastNo)
							{
								if (LastNo>=0)
									++p->FoundAtEnd[LastNo];
								LastNo = No;
							}

							if (p->FoundLastPos[No] == Pos)
								p->CheckForZero = 1;

							p->FoundLastPos[No] = Pos;
							++p->FoundTotal;
						}

						if (Load32LE(i+12)==0 && Pos==Load32LE(i-16+8))
						{
							p->CheckForZero = 1;
							break;
						}
					}
				}

				if (LastNo>=0)
					++p->FoundAtEnd[LastNo];
			}
			Reader->Input->Seek(Reader->Input,Save,SEEK_SET);
		}

		FreeBlock(&Buffer);
	}
}

static int Init(avi* p)
{
	int DataLength;
	int Type;
	format_reader* Reader = p->Format.Reader;

	if (!AllocBlock(sizeof(aviindex)*INDEXSTEP,&p->IndexBuffer,0,HEAP_ANY))
		return ERR_OUT_OF_MEMORY;

	memset(p->FoundAtEnd,0,sizeof(p->FoundAtEnd));
	memset(p->FoundLastPos,0,sizeof(p->FoundLastPos));
	p->LastStream = NULL;
	p->FoundTotal = 0;
	p->FoundStdIndex = 0;
	p->CheckForZero = 0;
	p->UnLimited = 1;
	p->IndexAdjustPos = 4;
	p->IndexPos = -1;
	p->IndexCount = 0;
	p->IndexReaded = 0;
	p->IndexBufferNo = -1;
	p->DataPos = -1;
	p->DataEnd = -1;
	p->ErrorIndex = 0;
	p->AudioLength = 0;

	memset(p->NameChar,0,sizeof(p->NameChar));
	memset(p->NameChar+'a',1,'z'-'a');
	memset(p->NameChar+'A',1,'Z'-'A');
	memset(p->NameChar+'0',1,'9'-'0');
	p->NameChar['_']=1;
	p->NameChar[' ']=1;

	Type = Reader->ReadLE32(Reader);
	DataLength = Reader->ReadLE32(Reader);

	if (Type != FOURCCLE('R','I','F','F'))
		return ERR_INVALID_DATA;

	if (DataLength > 256 && (p->Format.FileSize < 0 || p->Format.FileSize > DataLength + 8))
		p->Format.FileSize = DataLength + 8;

	Reader->ReadLE32(Reader); // 'AVI ' or 'AVIX'

	PreCheckIndex(p);
	return ERR_NONE;
}

static INLINE int ChunkTime(avistream* Stream, int DataLength)
{
	if (Stream->ByteRate)
		return DataLength; //byterate

	// packetrate
	if (DataLength > Stream->MaxPacket) 
		return (DataLength + Stream->MaxPacket - 1) / Stream->MaxPacket;
	return 1;
}

static void UpdateAviFrameRate(avi* p)
{
	if (QueryAdvanced(ADVANCED_AVIFRAMERATE) && p->AudioLength && p->VideoFrames)
	{
		int i;
		for (i=0;i<p->Format.StreamCount;++i)
		{
			avistream* Stream = (avistream*) p->Format.Streams[i];
			if (Stream->Stream.Format.Type == PACKET_VIDEO && Stream->Length)
			{
				Stream->MediaRate.Num = Scale64(p->AudioLength,(int64_t)p->AudioRate.Den*TICKSPERSEC,p->AudioRate.Num);
				Stream->MediaRate.Den = p->VideoFrames;
			}
		}
	}
}

static bool_t SubtitleTiming(format_packet* Packet,format_reader* Reader,int Length)
{
	int Hour0,Hour1,Min0,Min1,Sec0,Sec1,MSec0,MSec1;
	int i;
	tchar_t s[64];
	for (i=0;i<63 && Length>0;++i)
	{
		int ch = Reader->Read8(Reader);
		--Length;
		if (ch<0 || ch==']') break;
		s[i] = (tchar_t)ch;
	}
	s[i] = 0;

	if (stscanf(s,T("[%d:%d:%d.%d-%d:%d:%d.%d"),&Hour0,&Min0,&Sec0,&MSec0,&Hour1,&Min1,&Sec1,&MSec1)!=8)
	{
		Reader->Skip(Reader,Length);
		return 0;
	}
	Packet->RefTime = Scale(((Hour0*60+Min0)*60+Sec0)*1000+MSec0,TICKSPERSEC,1000);
	Packet->EndRefTime = Scale(((Hour1*60+Min1)*60+Sec1)*1000+MSec1,TICKSPERSEC,1000);
	Packet->Data = Reader->ReadAsRef(Reader,Length);
	return 1;
}

static void SetMediaTime(avistream* p,int Time)
{
	p->MediaTime = Time;
	p->ZeroChunkPos = ARRAYBEGIN(p->ZeroChunk,int);
	if (p->ZeroChunkPos)
		while (*p->ZeroChunkPos < Time)
			++p->ZeroChunkPos;
}

static void ReadMeta(avi* p, format_reader* Reader, int* DataLength)
{
	pin* Comment = &p->LastStream->Stream.Comment;
	tchar_t Meta[512];
	char UTF8[512];
	int Len = *DataLength;
	if (Len>=512) Len=511;
	Len = Reader->Read(Reader,UTF8,Len);
	if (Len>0)
	{
		*DataLength -= Len;
		UTF8[Len] = 0;
		tcscpy_s(Meta,TSIZEOF(Meta),T("LANGUAGE="));
		UTF8ToTcs(Meta+tcslen(Meta),TSIZEOF(Meta)-tcslen(Meta),UTF8);
		if (Comment->Node)
			Comment->Node->Set(Comment->Node,Comment->No,Meta,sizeof(Meta));
	}
}

static void CheckIndex(avi* p, format_reader* Reader);

static int ReadPacket(avi* p, format_reader* Reader, format_packet* Packet)
{
	avistream* Stream;
	int No,Ch,StartPos;
	int SubType,Type,DataLength;
	tick_t Duration;
	int LongsPerEntry;
	int IndexType;
	int Count;
	int BaseOffset;

	// find a valid chunk header first

	//DEBUG_MSG1(DEBUG_FORMAT,T("AVI Packet %08x"),Reader->FilePos);

	StartPos = Reader->FilePos;

	if (!p->UnLimited && p->DataEnd >= 0 && Reader->FilePos >= p->DataEnd)
		return ERR_END_OF_FILE;

	do
	{
		bool_t PossibleAlign = Reader->FilePos & 1;
		Type = 0;
		No = 0;
		while (No<32)
		{
			Ch = Reader->Read8(Reader);

			if (Ch>=0 && p->NameChar[Ch])
			{
				Type |= Ch << No;
				No += 8;

				if (No==32 && PossibleAlign)
				{
					int Stream = STREAMNO(Type);
					if (!ISDATA(Type) || ISDIGIT((Type>>16) & 255) || ISDIGIT((Type>>24) & 255) || 
						Stream <0 || Stream>=p->Format.StreamCount)
					{
						No -= 8;
						Type >>= 8;
					}
				}
			}
			else
			{
				if (!PossibleAlign)
				{
					Reader->OutOfSync = 1;
					if ((Reader->FilePos-StartPos)>=16384)
						return ERR_DATA_NOT_FOUND; // this will force the process loop to stop, so input thread can be woken up
					if (Reader->Eof(Reader))
						return ERR_END_OF_FILE;
				}
				No = 0;
				Type = 0;
				PossibleAlign = 0;
			}
		}

		if (!p->UnLimited && p->DataEnd >= 0 && Reader->FilePos >= p->DataEnd)
			return ERR_END_OF_FILE;

		DataLength = Reader->ReadLE32(Reader);

		if (DataLength<0 || (Reader->FilePos+DataLength<0) || (p->DataPos>=0 && p->Format.FileSize>=0 && Reader->FilePos+DataLength>p->Format.FileSize))
		{
			DataLength = -1;
			Reader->OutOfSync = 1;
			continue;
		}

		if (ISDATA(Type))
		{
			No = STREAMNO(Type);
			if (No >= 0 && No < p->Format.StreamCount)
			{
				//DEBUG_MSG3(-1,"AVI Packet stream:%d pos:%08x length:%d",No,Reader->FilePos,DataLength);

				Stream = (avistream*) p->Format.Streams[No];
				if (Stream->Stream.Reader != Reader)
					break;

				if (Reader->OutOfSync)
				{
					if (p->Format.ProcessTime >= 0)
					{
						int i;
						tick_t RefTime;
	
						// this won't solve the out of sync problem
						// but at least the streams won't be dropped

						for (i=0;i<p->Format.StreamCount;++i)
						{
							avistream* s = (avistream*) p->Format.Streams[i];
							if (s->Stream.Reader == Reader)
							{
								RefTime = s->RefStart+Scale64(s->MediaTime,s->MediaRate.Num,s->MediaRate.Den);
								if (RefTime < p->Format.ProcessTime - TICKSPERSEC)
									SetMediaTime(s,Scale64(p->Format.ProcessTime-s->RefStart,s->MediaRate.Den,s->MediaRate.Num));
							}
						}
					}
					Reader->OutOfSync = 0;
				}

				Packet->Stream = &Stream->Stream;

				if (Stream->ZeroChunkPos)
					while (*Stream->ZeroChunkPos == Stream->MediaTime)
					{
						Stream->MediaTime += ChunkTime(Stream,0);
						++Stream->ZeroChunkPos;
					}

				if (Stream->Stream.Format.Type == PACKET_SUBTITLE)
				{
					if (!SubtitleTiming(Packet,Reader,DataLength))
						continue;
				}
				else
				{
					Packet->Data = Reader->ReadAsRef(Reader,DataLength);
					Packet->RefTime = Stream->RefStart+Scale64(Stream->MediaTime,Stream->MediaRate.Num,Stream->MediaRate.Den);
				}

				DEBUG_MSG5(DEBUG_FORMAT,T("AVI stream:%d time:%d mediatime:%d pos:%08x length:%08x"),No,Packet->RefTime,Stream->MediaTime,Reader->FilePos,DataLength);

				Stream->MediaTime += ChunkTime(Stream,DataLength);
				return ERR_NONE;
			}
		}

		if (ISIDX(Type))
		{
			No = IDXNO(Type);
			if (No >= 0 && No < p->Format.StreamCount)
				break; // opendml index
		}

		switch (Type)
		{
		case FOURCCLE('R','I','F','F'):
			Reader->ReadLE32(Reader); // 'AVI ' or 'AVIX'
			return ERR_NONE;

		case FOURCCLE('a','v','i','h'):
			if (p->Format.HeaderLoaded) break;
			p->FramePeriod = Reader->ReadLE32(Reader);
			p->ByteRate = Reader->ReadLE32(Reader);
			DataLength -= 8;
			break;

		case FOURCCLE('i','n','d','x'):
			if (p->Format.HeaderLoaded) break;
			// opendml index

			LongsPerEntry = Reader->ReadLE16(Reader);
			Reader->Read8(Reader); //subtype
			IndexType = Reader->Read8(Reader);
			Count = Reader->ReadLE32(Reader);
			Type = Reader->ReadLE32(Reader);
			BaseOffset = (int)Reader->ReadLE64(Reader);
			Reader->Skip(Reader,4);
			DataLength -= 6*4;

			if (ISDATA(Type))
			{
				No = STREAMNO(Type);
				if (No >= 0 && No < p->Format.StreamCount && Count)
				{
					avisuperindex* s;

					Stream = (avistream*) p->Format.Streams[No];

					if (IndexType == AVI_INDEX_OF_CHUNKS && LongsPerEntry==2)
					{
						p->UnLimited = 1;
						p->Format.FileSize = -1;

						// create fake index of indexes

						Stream->SuperIndexCount = 1;
						Stream->SuperIndex = s = (avisuperindex*) malloc(sizeof(avisuperindex));

						s->Offset = Reader->FilePos - 6*4 - 8;
						s->Size = DataLength + 6*4 + 8;
						s->StartTime = 0;
						s->EndTime = 0;
						s->LastData = 0;

						for (No=0;No<Count;++No)
						{
							int Data = BaseOffset + Reader->ReadLE32(Reader) - 8;
							int Size = Reader->ReadLE32(Reader) & ~AVI_INDEX_KEY;

							if (s->LastData < Data)
								s->LastData = Data;

							s->EndTime += ChunkTime(Stream,Size);
						}
					}
					if (IndexType == AVI_INDEX_OF_INDEXES && LongsPerEntry==4)
					{
						int Time;

						p->UnLimited = 1;
						p->Format.FileSize = -1;

						// load index of indexes

						Stream->SuperIndexCount = Count;
						Stream->SuperIndex = s = (avisuperindex*) malloc(sizeof(avisuperindex)*Count);

						Time = 0;
						for (No=0;No<Count;++No,++s)
						{
							s->Offset = (int)Reader->ReadLE64(Reader);
							s->Size = Reader->ReadLE32(Reader);
							s->StartTime = Time;
							Time += Reader->ReadLE32(Reader) * Stream->SampleSize;
  							s->EndTime = Time;
							s->LastData = -1;
							DataLength -= 16;
						}

						if (Count && !p->FoundStdIndex && !p->CheckForZero && Stream->Stream.Format.Type == PACKET_VIDEO)
						{
							LockEnter(p->Format.InputLock);
							PreCheckIndexODML(p,Stream);
							LockLeave(p->Format.InputLock);
						}
					}
				}
			}

			break;

		case FOURCCLE('s','t','r','h'):
			if (p->Format.HeaderLoaded) break;

			p->HeadType = Reader->ReadLE32(Reader);
			DataLength -= 4;

			if (p->HeadType == FOURCCLE('v','i','d','s'))
			{
				p->VideoHandler = Reader->ReadLE32(Reader);

				Reader->ReadLE32(Reader); // flags
				Reader->ReadLE16(Reader); // priority
				Reader->ReadLE16(Reader); // language
				Reader->ReadLE32(Reader); 

				p->VideoFPS.Den = Reader->ReadLE32(Reader); 
				p->VideoFPS.Num = Reader->ReadLE32(Reader); 

				if (!p->VideoFPS.Den || !p->VideoFPS.Num)
				{
					p->VideoFPS.Den = 1;
					p->VideoFPS.Num = 25;
				}
				if (p->VideoFPS.Den==1 && p->VideoFPS.Num >= 12000) //not important
					p->VideoFPS.Den = 1000;

				p->VideoStart = Reader->ReadLE32(Reader);
				p->VideoFrames = Reader->ReadLE32(Reader);

				DataLength -= 32;
			}
			else
			if (p->HeadType == FOURCCLE('a','u','d','s'))
			{
				Reader->ReadLE32(Reader); // format
				Reader->ReadLE32(Reader); // flags
				Reader->ReadLE16(Reader); // priority
				Reader->ReadLE16(Reader); // language
				Reader->ReadLE32(Reader); 
				p->AudioRate.Den = Reader->ReadLE32(Reader); 
				p->AudioRate.Num = Reader->ReadLE32(Reader); 
				p->AudioStart = Reader->ReadLE32(Reader);
				p->AudioLength = Reader->ReadLE32(Reader);

				Reader->ReadLE32(Reader); // initialframes
				Reader->ReadLE32(Reader); // suggested buffersize

				p->AudioSampleSize = Reader->ReadLE32(Reader);

				DataLength -= 44;
			}
			break;

		case FOURCCLE('s','t','r','n'):
			if (p->Format.HeaderLoaded) break;
			if (p->LastStream && DataLength)
				ReadMeta(p,Reader,&DataLength);
			break;

		case FOURCCLE('s','t','r','f'):
			if (p->Format.HeaderLoaded) break;
			if (p->HeadType == FOURCCLE('v','i','d','s'))
			{
				p->LastStream = Stream = (avistream*) Format_AddStream(&p->Format,sizeof(avistream));
				if (Stream)
				{
					Stream->Index = NULL;
					Stream->SuperIndex = NULL;
					Stream->ByteRate = 0;
					Stream->Stream.Fragmented = 0;
					Stream->SampleSize = 1;
					Stream->MaxPacket = MAX_INT;
					Format_BitmapInfo(Reader,&Stream->Stream,DataLength);

					if (Stream->Stream.Format.Format.Video.Pixel.FourCC == FOURCC('D','X','S','B'))
					{
						PacketFormatClear(&Stream->Stream.Format);
						Stream->Stream.Format.Type = PACKET_SUBTITLE;
						Stream->Stream.Format.Format.Subtitle.FourCC = FOURCC('D','X','S','B');
					}
					else
					{
						if (Stream->Stream.Format.Format.Video.Pixel.FourCC == 4)
							Stream->Stream.Format.Format.Video.Pixel.FourCC = UpperFourCC(p->VideoHandler);

						Stream->MediaRate.Den = p->VideoFPS.Num;
						Stream->MediaRate.Num = (int64_t)p->VideoFPS.Den * TICKSPERSEC;
						Stream->RefStart = Scale64(p->VideoStart,Stream->MediaRate.Num,Stream->MediaRate.Den);
						Stream->Length = p->VideoFrames;
						Stream->Stream.Format.PacketRate = p->VideoFPS;

						if (p->VideoFrames)
						{
							Duration = Scale64(p->VideoFrames,Stream->MediaRate.Num,Stream->MediaRate.Den);
							if (p->Format.Duration < Duration)
								p->Format.Duration = Duration;
						}

						UpdateAviFrameRate(p);
					}
					Format_PrepairStream(&p->Format,&Stream->Stream);
				}
				else
					Reader->Skip(Reader,DataLength);

				return ERR_NONE;
			}
			else
			if (p->HeadType == FOURCCLE('a','u','d','s'))
			{
				p->LastStream = Stream = (avistream*) Format_AddStream(&p->Format,sizeof(avistream));
				if (Stream)
				{
					Format_WaveFormat(Reader,&Stream->Stream,DataLength);

					// some encoders doesn't set AudioSampleSize, but still using CBR mode
					// detect it by insane packet rate
					if (!p->AudioSampleSize && p->AudioRate.Den*1000<=p->AudioRate.Num)
						p->AudioSampleSize = Stream->Stream.Format.Format.Audio.BlockAlign;

					Stream->Index = NULL;
					Stream->SuperIndex = NULL;
					Stream->ByteRate = p->AudioSampleSize != 0;
					Stream->Stream.Fragmented = Stream->ByteRate && p->AudioSampleSize <= 4;
					
					if (!Stream->ByteRate)
					{
						// VBR (packetrate)
						Stream->MediaRate.Den = p->AudioRate.Num;
						Stream->MediaRate.Num = (int64_t)p->AudioRate.Den * TICKSPERSEC;
						if (p->AudioRate.Num == Stream->Stream.Format.Format.Audio.SampleRate)
							Stream->MaxPacket = p->AudioRate.Den;
						else
							Stream->MaxPacket = MAX_INT;
						Stream->SampleSize = 1;
					}
					else
					{
						// CBR (byterate)
						
						// some digital cameras don't fill AudioSampleSize correctly only BlockAlign (with ADPCM)
						if (p->AudioSampleSize < Stream->Stream.Format.Format.Audio.BlockAlign)
							p->AudioSampleSize = Stream->Stream.Format.Format.Audio.BlockAlign;

						if (Stream->Stream.Format.Format.Audio.Format == 0x55 /*MP3*/ && 
							p->AudioRate.Num == 4977)
						{
							Stream->MediaRate.Den = (p->AudioRate.Num*16-7)*p->AudioSampleSize;
							Stream->MediaRate.Num = (int64_t)p->AudioRate.Den*TICKSPERSEC*16;
						}
						else
						{
							Stream->MediaRate.Den = p->AudioRate.Num*p->AudioSampleSize;
							Stream->MediaRate.Num = (int64_t)p->AudioRate.Den*TICKSPERSEC;
						}

						Stream->SampleSize = p->AudioSampleSize;
					}

					Stream->RefStart = Scale64(p->AudioStart,(int64_t)p->AudioRate.Den*TICKSPERSEC,p->AudioRate.Num);
					Stream->Length = p->AudioLength;

					if (p->AudioLength)
					{
						Duration = Scale64(p->AudioLength,(int64_t)p->AudioRate.Den*TICKSPERSEC,p->AudioRate.Num);
						if (Duration>0 && p->Format.Duration < Duration)
							p->Format.Duration = Duration;
					}

					UpdateAviFrameRate(p);
					Format_PrepairStream(&p->Format,&Stream->Stream);
				}
				else
					Reader->Skip(Reader,DataLength);
				return ERR_NONE;
			}
			else
				p->LastStream = NULL;
			break;

		case FOURCCLE('L','I','S','T'):
			SubType = Reader->ReadLE32(Reader);
			DataLength -= 4;

			switch (SubType)
			{
			case FOURCCLE('s','t','r','l'):
				return ERR_NONE;

			case FOURCCLE('h','d','r','l'):
				return ERR_NONE;

			case FOURCCLE('m','o','v','i'):
				if (p->Format.HeaderLoaded) return ERR_NONE;
				p->DataPos = Reader->FilePos;
				p->DataEnd = DataLength + Reader->FilePos;
				p->Format.HeaderLoaded = 1;

				if (p->FoundTotal >= 256 && p->Format.StreamCount>1)
				{
					for (No=0;No<p->Format.StreamCount && No<8;++No)
						if (p->FoundAtEnd[No] < 2)
							p->CheckForZero = 1; // possibly non interleaved streams
				}

				if (p->CheckForZero)
				{
					LockEnter(p->Format.InputLock);
					CheckIndex(p,Reader);
					LockLeave(p->Format.InputLock);
				}

				for (No=0;No<p->Format.StreamCount;++No)
					SetMediaTime((avistream*)p->Format.Streams[No],0);

				return ERR_NONE;

			case FOURCCLE('o','d','m','l'):
				break;

			default:
				return ERR_NONE;
			}
			break;

		case FOURCCLE('J','U','N','K'):
		case FOURCCLE('i','d','x','1'):
			break;

		default: 
			if (Reader->OutOfSync || DataLength > 256*1024) // unknown
				DataLength = -1;
		}
	}
	while (DataLength<0);

	Reader->Skip(Reader,DataLength);

	return ERR_NONE;
}

static int ErrorIndex(avi* p,stream* Input,filepos_t OldFilePos)
{
	if (OldFilePos>=0)
	{
		if (Input)
			Input->Seek(Input,OldFilePos,SEEK_SET);

		if (!p->ErrorIndex)
		{
			p->ErrorIndex = 1;
			ShowError(p->Format.Format.Class,AVI_ID,AVI_NO_INDEX);
		}
	}
	return ERR_NOT_SUPPORTED;
}

static INLINE const aviindex* IndexBuffer(avi* p,int n)
{
	return ((const aviindex*)p->IndexBuffer.Ptr)+n;
}

static int LoadIndexBuffer(avi* p,stream* Input,int No,filepos_t OldFilePos)
{
	if (p->IndexBufferNo != No)
	{
		int Bytes = (p->IndexCount - No*INDEXSTEP)*sizeof(aviindex);
		if (Bytes > INDEXSTEP*sizeof(aviindex))
			Bytes = INDEXSTEP*sizeof(aviindex);

		if (Input->Seek(Input,p->IndexPos+No*INDEXSTEP*sizeof(aviindex),SEEK_SET)<0)
			return ErrorIndex(p,Input,OldFilePos);

		if (Input->ReadBlock(Input,&p->IndexBuffer,0,Bytes) != Bytes)
			return ErrorIndex(p,Input,OldFilePos);

		p->IndexBufferNo = No;

		if (No == 0)
		{
			if (INT32LE(IndexBuffer(p,0)->Pos) == p->DataPos)
				p->IndexAdjustPos = p->DataPos;
			else
				p->IndexAdjustPos = 4;
		}
	}
	return ERR_NONE;
}

static int ReadIndex(stream* Input,avistream* Stream,avisuperindex* Index,int MediaTime,int DstPos,bool_t PrevKey)
{
	bool_t NeedKey = Stream->Stream.Format.Type == PACKET_VIDEO;
	avistdindex StdIndex;
	int No;
	int FoundPos = -1;
	int32_t* i; 
	int LookBack = 0;

	if (!NeedKey)
		PrevKey = 0;

	if (PrevKey)
		LookBack = 300;

	if (DstPos>=0 && Index->LastData>=0 && DstPos > Index->LastData)
		return -1;

	if (MediaTime>=0 && Index->EndTime + LookBack <= MediaTime)
		return -1;

	if (Input->Seek(Input,Index->Offset,SEEK_SET) < 0)
		return -2;

	if (Input->Read(Input,&StdIndex,sizeof(StdIndex)) != sizeof(StdIndex))
		return -1;

	if (StdIndex.IndexType != AVI_INDEX_OF_CHUNKS ||
		StdIndex.LongsPerEntry != 2)
		return -1;

	i = (int32_t*) malloc(8*StdIndex.Count);
	if (!i)
		return -1;

	if (Input->Read(Input,i,8*StdIndex.Count) != 8*StdIndex.Count)
	{
		free(i);
		return -1;
	}

	if (Index->LastData<0)
	{
		Index->LastData = 0;
		for (No=0;No<StdIndex.Count;++No)
		{
			int Data = StdIndex.OffsetLow + i[No*2] - 8;
			int Size = i[No*2+1] & ~AVI_INDEX_KEY;
			if (Size && Index->LastData < Data)
				Index->LastData = Data;
		}
	}
	
	Stream->NewMediaTime = Index->StartTime;

	for (No=0;No<StdIndex.Count;++No)
	{
		int Data = StdIndex.OffsetLow + i[No*2] - 8;
		int Size = i[No*2+1];

		if (MediaTime>=0)
		{
			if (Stream->NewMediaTime >= MediaTime && (!NeedKey || !(Size & AVI_INDEX_KEY))) 
			{
				if (PrevKey && Stream->NewMediaTime != MediaTime && Stream->PrevKey>=0)
				{
					Stream->NewMediaTime = Stream->PrevMediaTime;
					FoundPos = Stream->PrevKey; // use previous key
				}
				else
					FoundPos = Data; // found sample after mediatime
				break;
			}

			if (PrevKey && !(Size & AVI_INDEX_KEY))
			{
				Stream->PrevMediaTime = Stream->NewMediaTime;
				Stream->PrevKey = Data;
			}
		}

		if (DstPos>=0 && Data >= DstPos) 
		{
			FoundPos = Data; // found a sample after the destination position
			break; 
		}

		Stream->NewMediaTime = Stream->NewMediaTime + ChunkTime(Stream,Size & ~AVI_INDEX_KEY);
	}

	free(i);
	return FoundPos;
}

static int RestorePrevKey(avi* p,avistream* Stream,int No,int OldFilePos,int* Pos)
{
	int i,j;
	avistream* s;

	if (Stream->PrevKeyBuffer != No)
	{
		int Result = LoadIndexBuffer(p,Stream->Stream.Reader->Input,Stream->PrevKeyBuffer,OldFilePos);
		if (Result != ERR_NONE)
			return Result;

		No = Stream->PrevKeyBuffer;
	}

	// restart this block and recalc NewMediaTime
	for (j=0;j<p->Format.StreamCount;++j)
	{
		s = (avistream*) p->Format.Streams[j];
		s->NewMediaTime = s->Index[No];
	}

	for (i=0;i<Stream->PrevKey;++i)
	{
		j = STREAMNO(IndexBuffer(p,i)->Id);
		if (j>=0 && j<p->Format.StreamCount)
		{
			s = (avistream*) p->Format.Streams[j];
			s->NewMediaTime += ChunkTime(s,IndexBuffer(p,i)->Length);
		}
	}

	*Pos = INT32LE(IndexBuffer(p,i)->Pos) - p->IndexAdjustPos;
	return ERR_NONE;
}

static int FindIndexPos(avi* p,stream* Input)
{
	int OldFilePos = Input->Seek(Input,0,SEEK_CUR);
	int Pos = p->DataEnd;
	// try to find index block

	if (Input->Seek(Input,Pos,SEEK_SET) < 0)
		return ERR_NOT_SUPPORTED;

	for (;;)
	{
		int32_t Head[2];

		if (Pos & 1)
		{
			if (Input->Read(Input,Head,sizeof(Head)) != sizeof(Head))
				return ErrorIndex(p,Input,OldFilePos);

			Pos += sizeof(Head);

			if (Head[0] != FOURCC('i','d','x','1'))
			{
				memmove((char*)Head,(char*)Head+1,sizeof(Head)-1);
				if (Input->Read(Input,(char*)Head+sizeof(Head)-1,1) != 1)
					return ErrorIndex(p,Input,OldFilePos);
				++Pos;
			}
		}
		else
		{
			if (Input->Read(Input,Head,sizeof(Head)) != sizeof(Head))
				return ErrorIndex(p,Input,OldFilePos);
			Pos += sizeof(Head);
		}

		if (Head[0] == FOURCC('i','d','x','1'))
		{
			int i,No;

			p->IndexCount = Head[1] / sizeof(aviindex);

			i = ((p->IndexCount + INDEXSTEP - 1) / INDEXSTEP) + 1;

			for (No=0;No<p->Format.StreamCount;++No)
			{
				avistream* s = (avistream*) p->Format.Streams[No];
				s->Index = (int*) malloc(sizeof(int)*i);
				if (!s->Index)
					return ERR_OUT_OF_MEMORY;

				s->Index[0] = 0;
			}

			p->IndexPos = Pos;
			p->IndexReaded = 0;
			break;
		}

		if (Head[1]<0 || (Pos+Head[1]<0))
			return ErrorIndex(p,Input,OldFilePos);

		Pos += Head[1];

		if (Input->Seek(Input,Pos,SEEK_SET) != Pos)
			return ErrorIndex(p,Input,OldFilePos);
	}
	return ERR_NONE;
}

static NOINLINE int CheckIndexBuffer(avi* p,stream* Input,int No,filepos_t OldFilePos,int IndexCount)
{
	// load page and calc sum mediatime
	if (p->IndexReaded <= No)
	{
		int i,j;
		int Result = LoadIndexBuffer(p,Input,No,OldFilePos);
		if (Result != ERR_NONE)
			return Result;

		for (j=0;j<p->Format.StreamCount;++j)
		{
			avistream* s = (avistream*) p->Format.Streams[j];
			s->Index[No+1] = s->Index[No];
		}

		for (i=0;i<IndexCount;++i)
		{
			j = STREAMNO(IndexBuffer(p,i)->Id);
			if (j>=0 && j<p->Format.StreamCount)
			{
				avistream* s = (avistream*) p->Format.Streams[j];
				s->Index[No+1] += ChunkTime(s,INT32LE(IndexBuffer(p,i)->Length));
			}
		}

		p->IndexReaded = No+1;
	}
	return ERR_NONE;
}

static int Seek(avi* p, tick_t Time, filepos_t FilePos, bool_t PrevKey)
{
	int Result = ERR_NONE;
	int RNo;
	if (p->DataPos < 0)
	{
		// no avi header yet, only seek to the beginning supported

		if (Time>0 || FilePos>0)
			return ERR_NOT_SUPPORTED;

		p->Format.Reader[0].OutOfSync = 0;
		return Format_Seek(&p->Format,0,SEEK_SET);
	}

	for (RNo=0;RNo<MAXREADER;++RNo)
	{
		filepos_t Pos = -1;
		avistream* Stream;
		avistream* s;
		int i,j,No;
		format_reader* Reader = &p->Format.Reader[RNo];
		stream* Input = Reader->Input;
		filepos_t OldReaderPos = Reader->FilePos;
		filepos_t OldFilePos;

		if (!Input)
			break;

		OldFilePos = Input->Seek(Input,0,SEEK_CUR);
		
		if (Time <= 0 && FilePos <= 0)
		{
			// seek to the beginning (no index needed for that)

			Pos = Reader->OffsetMin<MAX_INT?Reader->OffsetMin:p->DataPos;

			for (j=0;j<p->Format.StreamCount;++j)
				if (p->Format.Streams[j]->Reader == Reader)
					((avistream*)p->Format.Streams[j])->NewMediaTime = 0;
		}
		else
		{
			Stream = (avistream*) Format_DefSyncStream(&p->Format,Reader);
			if (Stream)
			{
				bool_t NeedKey = Stream->Stream.Format.Type == PACKET_VIDEO;
				int MediaTime = Scale64(Time,Stream->MediaRate.Den,Stream->MediaRate.Num);

				Stream->PrevKey = -1;

				if (PrevKey)
					++MediaTime; // seek to same position even if there is rounding error

				if (Stream->SuperIndex)
				{
					// using OpenDML index
					if (MediaTime >= Stream->SuperIndex[Stream->SuperIndexCount-1].EndTime)
						MediaTime = Stream->SuperIndex[Stream->SuperIndexCount-1].EndTime-1;

					// find position by MediaTime
					for (No=0;No<Stream->SuperIndexCount;++No)
					{
						Pos = ReadIndex(Input,Stream,Stream->SuperIndex+No,MediaTime,-1,PrevKey);
						if (Pos == -2)
							return ERR_NOT_SUPPORTED;

						if (Pos >= 0)
							break;
					}

					if (Pos<0)
					{
						if (PrevKey && Stream->PrevKey>=0)
						{
							Stream->NewMediaTime = Stream->PrevMediaTime;
							Pos = Stream->PrevKey;
						}
						else
						{
							Stream->NewMediaTime = Stream->SuperIndex[Stream->SuperIndexCount-1].EndTime;
							Pos = Stream->SuperIndex[Stream->SuperIndexCount-1].LastData;

							if (Pos<0)
								return ErrorIndex(p,Input,OldFilePos);
						}
					}

					// calculate NewMediaTime for all other streams
					for (j=0;j<p->Format.StreamCount;++j)
					{
						s = (avistream*) p->Format.Streams[j];
						if (s->Stream.Reader==Reader && s != Stream)
						{
							// find position by Pos
							for (No=0;No<s->SuperIndexCount;++No)
								if (ReadIndex(Input,s,s->SuperIndex+No,-1,Pos,0) >= 0)
									break;

							if (No==s->SuperIndexCount)
								s->NewMediaTime = s->SuperIndex[s->SuperIndexCount-1].EndTime;
						}
					}
				}
				else
				{
					int Next;
					int IndexCount,IndexLeft;
					tick_t LookBack = 0;

					// do we have the index block?
					if (p->IndexPos < 0)
					{
						Result = FindIndexPos(p,Input);
						if (Result!=ERR_NONE)
							return Result;
					}

					IndexLeft = p->IndexCount;

					if (!NeedKey)
						PrevKey = 0;

					if (PrevKey)
						LookBack = 300;

					// find the index page

					for (No=0;IndexLeft>0;++No,IndexLeft-=INDEXSTEP)
					{
						IndexCount = IndexLeft;
						if (IndexCount > INDEXSTEP)
							IndexCount = INDEXSTEP;

						Result = CheckIndexBuffer(p,Input,No,OldFilePos,IndexCount);
						if (Result != ERR_NONE)
							return Result;

						//DEBUG_MSG4(DEBUG_FORMAT,"AVI IndexBlock no:%d start:%d end:%d (target:%d)",No,Stream->Index[No],Stream->Index[No+1],MediaTime);

						if (Stream->Index[No]!=Stream->Index[No+1] &&
							(Stream->Index[No+1]+LookBack > MediaTime || IndexLeft<2*INDEXSTEP))
						{
							Result = LoadIndexBuffer(p,Input,No,OldFilePos);
							if (Result != ERR_NONE)
								return Result;

							for (j=0;j<p->Format.StreamCount;++j)
							{
								s = (avistream*) p->Format.Streams[j];
								if (s->Stream.Reader == Reader)
									s->NewMediaTime = s->Index[No];
							}

							// find sub page position

							for (i=0;i<IndexCount;++i)
							{
								j = STREAMNO(IndexBuffer(p,i)->Id);
								if (j>=0 && j<p->Format.StreamCount && p->Format.Streams[j]->Reader==Reader)
								{
									s = (avistream*) p->Format.Streams[j];
									Next = s->NewMediaTime + ChunkTime(s,IndexBuffer(p,i)->Length);

									//DEBUG_MSG3(DEBUG_FORMAT,"AVI Index stream:%d pos:%d flag:%d",j,INT32LE(IndexBuffer(p,i)->Pos),IndexBuffer(p,i)->Flags[0]);

									if (s==Stream)
									{
										Pos = INT32LE(IndexBuffer(p,i)->Pos) - p->IndexAdjustPos;

										if (s->NewMediaTime >= MediaTime)
										{
											// only accept keyframes with valid position
											if (Pos >= 0 && Pos < p->DataEnd - p->DataPos &&
												(!NeedKey || (IndexBuffer(p,i)->Flags[0] & 0x10)))
											{
												if (PrevKey && s->NewMediaTime != MediaTime && Stream->PrevKey>=0)
												{
													Result = RestorePrevKey(p,Stream,No,OldFilePos,&Pos);
													if (Result != ERR_NONE)
														return Result;
												}
												break;
											}
										}

										if (Pos >= 0 && Pos < p->DataEnd - p->DataPos &&
											(IndexBuffer(p,i)->Flags[0] & 0x10))
										{
											Stream->PrevKey = i;
											Stream->PrevKeyBuffer = No;
										}
									}

									s->NewMediaTime = Next;
								}
							}
								
							// found? 
							if (i<IndexCount)
								break;
						}
					}

					if (IndexLeft <= 0)
					{
						if (Stream->PrevKey>=0)
						{
							Result = RestorePrevKey(p,Stream,No,OldFilePos,&Pos);
							if (Result != ERR_NONE)
								return Result;
						}
						else
						{
							// go to end
							for (j=0;j<p->Format.StreamCount;++j)
							{
								s = (avistream*) p->Format.Streams[j];
								s->NewMediaTime = s->Index[p->IndexReaded];
							}

							Pos = p->DataEnd - p->DataPos;
						}
					}

					Pos += p->DataPos;
				}

				if (NeedKey && Stream->NewMediaTime >= 0) // use updated time with other Readers
					Time = Scale64(Stream->NewMediaTime,Stream->MediaRate.Num,Stream->MediaRate.Den);
			}
		}

		if (Pos>=0)
		{
			Reader->FilePos = -1; // force seek, because Input changed
			if (Reader->Seek(Reader,Pos,SEEK_SET) != ERR_NONE)
			{
				Reader->FilePos = OldReaderPos;
				// restore old input position
				Input->Seek(Input,OldFilePos,SEEK_SET);
				return ERR_NOT_SUPPORTED;
			}

			// set new positions
			for (j=0;j<p->Format.StreamCount;++j)
				if (p->Format.Streams[j]->Reader == Reader)
				{
					s = (avistream*) p->Format.Streams[j];
					SetMediaTime(s,s->NewMediaTime);
				}

			Reader->OutOfSync = 0;
		}
	}

	Format_AfterSeek(&p->Format);
	return ERR_NONE;
}

static NOINLINE void AddZeroChunk(avistream* Stream)
{
	ArrayAppend(&Stream->ZeroChunk,&Stream->NewMediaTime,sizeof(Stream->NewMediaTime),512);
}

static void CheckIndex(avi* p, format_reader* Reader)
{
	bool_t FlushBuffers = 0;
	avistream* Stream;
	int i,j,k;
	bool_t OpenDML = 0;
	array Array = {NULL};
	stream* Input = Reader->Input;
	filepos_t OldFilePos = Input->Seek(Input,0,SEEK_CUR);
	filepos_t OldReaderPos = Reader->FilePos;

	if (OldFilePos<0)
		return;

	for (i=0;i<p->Format.StreamCount;++i)
	{
		Stream = (avistream*)p->Format.Streams[i];
		Stream->NewMediaTime = 0;
		Stream->OffsetMin = MAX_INT;
		Stream->OffsetMax = 0;
		Stream->LastPos = 0;

		if (Stream->SuperIndex) // we need non video streams as well for offsetmin/max
		{
			OpenDML = 1;
		
			for (j=0;j<Stream->SuperIndexCount;++j)
			{
				avistdindex StdIndex;

				if (Input->Seek(Input,Stream->SuperIndex[j].Offset,SEEK_SET) < 0)
					break;

				if (Input->Read(Input,&StdIndex,sizeof(StdIndex)) != sizeof(StdIndex))
					break;

				if (StdIndex.IndexType != AVI_INDEX_OF_CHUNKS ||
					StdIndex.LongsPerEntry != 2)
					break;

				ArrayDrop(&Array);
				if (!ArrayAppend(&Array,NULL,8*StdIndex.Count,1024))
					break;

				if (Input->Read(Input,ARRAYBEGIN(Array,int32_t),8*StdIndex.Count) != 8*StdIndex.Count)
					break;

				for (k=0;k<StdIndex.Count;++k)
				{
					int Pos = StdIndex.OffsetLow + ARRAYBEGIN(Array,int32_t)[k*2] - 8;
					int Size = ARRAYBEGIN(Array,int32_t)[k*2+1] & ~AVI_INDEX_KEY;
					if (!Size)
						AddZeroChunk(Stream);
					else
					{
						if (Stream->OffsetMin>Pos)
							Stream->OffsetMin=Pos;
						if (Stream->OffsetMax<Pos)
							Stream->OffsetMax=Pos;
					}
					Stream->NewMediaTime = Stream->NewMediaTime + ChunkTime(Stream,Size);
				}
			}
		}
	}

	if (!OpenDML && (p->IndexPos>=0 || FindIndexPos(p,Input)==ERR_NONE))
	{
		int IndexLeft = p->IndexCount;
		int IndexCount;
		int LastPos = 0;

		for (i=0;IndexLeft>0;++i,IndexLeft-=INDEXSTEP)
		{
			IndexCount = IndexLeft;
			if (IndexCount > INDEXSTEP)
				IndexCount = INDEXSTEP;

			if (CheckIndexBuffer(p,Input,i,-1,IndexCount)==ERR_NONE && 
				LoadIndexBuffer(p,Input,i,-1)==ERR_NONE)
			{
				for (k=0;k<IndexCount;++k)
				{
					j = STREAMNO(IndexBuffer(p,k)->Id);
					if (j>=0 && j<p->Format.StreamCount)
					{
						int Pos = IndexBuffer(p,k)->Pos - p->IndexAdjustPos + p->DataPos;
						int Size = IndexBuffer(p,k)->Length;
						Stream = (avistream*) p->Format.Streams[j];
						if ((Size==0 && Pos==LastPos) || (Pos==Stream->LastPos))
							AddZeroChunk(Stream);
						if (Size)
						{
							if (Stream->OffsetMin>Pos)
								Stream->OffsetMin=Pos;
							if (Stream->OffsetMax<Pos)
								Stream->OffsetMax=Pos;
						}
						LastPos = Pos;
						Stream->LastPos=Pos;
						Stream->NewMediaTime = Stream->NewMediaTime + ChunkTime(Stream,Size);
					}
				}
			}
		}
	}

	for (i=0;i<p->Format.StreamCount;++i)
	{
		Stream = (avistream*)p->Format.Streams[i];
		if (!ARRAYEMPTY(Stream->ZeroChunk))
		{
			Stream->NewMediaTime = MAX_INT;
			AddZeroChunk(Stream);
		}
		if (Stream->OffsetMax)
		{
			format_reader* Reader = Format_FindReader(&p->Format,Stream->OffsetMin,Stream->OffsetMax);
			if (Reader)
				Stream->Stream.Reader = Reader;
		}
	}

	ArrayClear(&Array);

	for (i=0;i<MAXREADER;++i)
	{
		format_reader* v = &p->Format.Reader[i];
		if (v->Input && v->OffsetMax>0)
		{
			v->Seek(v,v->OffsetMin,SEEK_SET);
			FlushBuffers = 1;
			if (Reader == v)
				OldReaderPos = v->OffsetMin;
		}
	}

	if (!FlushBuffers)
		Input->Seek(Input,OldFilePos,SEEK_SET);
	else
	{
		// probably first reader already allocated all the buffers
		Reader->FilePos = -1;
		Reader->Seek(Reader,OldReaderPos,SEEK_SET);
	}
}

static int Set(avi* p,int No,const void* Data,int Size)
{
	if (No == NODE_SETTINGSCHANGED)
		UpdateAviFrameRate(p);

	return FormatBaseSet(&p->Format,No,Data,Size);
}

static void FreeStream(avi* p, avistream* Stream)
{
	free(Stream->Index);
	free(Stream->SuperIndex);
	ArrayClear(&Stream->ZeroChunk);
}

static int Create(avi* p)
{
	p->Format.Format.Set = (nodeset)Set;
	p->Format.Init = (fmtfunc)Init;
	p->Format.Done = (fmtvoid)Done;
	p->Format.Seek = (fmtseek)Seek;
	p->Format.ReadPacket = (fmtreadpacket)ReadPacket;
	p->Format.FreeStream = (fmtstream)FreeStream;
	p->Format.MinHeaderLoad = MAX_INT; //manualy setting HeaderLoaded
	return ERR_NONE;
}

static const nodedef AVI = 
{
	sizeof(avi),
	AVI_ID,
	FORMATBASE_CLASS,
	PRI_DEFAULT,
	(nodecreate)Create,
};

void AVI_Init()
{
	NodeRegisterClass(&AVI);
}

void AVI_Done()
{
	NodeUnRegisterClass(AVI_ID);
}