// Open function modified by Donald Graft as part of fix for dropped frames and random frame access.
int CMPEG2Decoder::Open(const char *path, DstFormat dstFormat)
{
	char buf[2048], *buf_p;

	Choose_Prediction(this->fastMC);

	m_dstFormat = dstFormat;
	char ID[80], PASS[80] = "DGIndexProjectFile08";
	DWORD i, j, size, code, type, tff, rff, film, ntsc, gop, top, bottom, mapping;
	int repeat_on, repeat_off, repeat_init;
	int vob_id, cell_id;
	__int64 position;
	int m, n;

	CMPEG2Decoder* out = this;

	out->VF_File = fopen(path, "r");
	if (fgets(ID, 79, out->VF_File)==NULL)
		return 0;
	if (strncmp(ID, PASS, 20))
		return 0;

	fscanf(out->VF_File, "%d", &File_Limit);
	i = File_Limit;
	while (i)
	{
		fscanf(out->VF_File, "%d ", &j);
		Infilename[File_Limit-i] = (char*)aligned_malloc(_MAX_PATH, 16);
		fgets(Infilename[File_Limit-i], j+1, out->VF_File);
		if ((Infile[File_Limit-i] = _open(Infilename[File_Limit-i], _O_RDONLY | _O_BINARY))==-1)
			return 0;
		i--;
	}

	fscanf(out->VF_File, "\nStream_Type=%d\n", &SystemStream_Flag);
	if ( SystemStream_Flag == 2 )
		fscanf(out->VF_File, "MPEG2_Transport_PID=%x,%x\n", &MPEG2_Transport_VideoPID,	&MPEG2_Transport_AudioPID);

	long nCurrentPos = ftell(out->VF_File);
	char szTempText[50];

	fscanf(out->VF_File, "iDCT_Algorithm=%d", &IDCT_Flag);
	fscanf(out->VF_File, "%s", szTempText);
	
	fseek(out->VF_File, nCurrentPos, SEEK_SET);

	fscanf(out->VF_File, "iDCT_Algorithm=%d (1:MMX 2:SSEMMX 3:FPU 4:REF 5:SSE2MMX)\n", &IDCT_Flag);

	switch (IDCT_Flag)
	{
		case IDCT_MMX:
			idctFunc = MMX_IDCT;
			break;

		case IDCT_SSEMMX:
			idctFunc = SSEMMX_IDCT;
			if (!cpu.ssemmx)
			{
				IDCT_Flag = IDCT_MMX;
				idctFunc = MMX_IDCT;
			}
			break;

		case IDCT_FPU:
			if (!fpuinit) 
			{
				Initialize_FPU_IDCT();
				fpuinit = true;
			}
			idctFunc = FPU_IDCT;
			break;

		case IDCT_REF:
			if (!refinit) 
			{
				Initialize_REF_IDCT();
				refinit = true;
			}
			idctFunc = REF_IDCT;
			break;

		case IDCT_SSE2MMX:
			idctFunc = SSE2MMX_IDCT;
			if (!cpu.sse2mmx)
			{
				IDCT_Flag = IDCT_SSEMMX;
				idctFunc = SSEMMX_IDCT;
				if (!cpu.ssemmx)
				{
					IDCT_Flag = IDCT_MMX;
					idctFunc = MMX_IDCT;
				}
			}
			break;
		
		case IDCT_SKALSSE:
			idctFunc = Skl_IDct16_Sparse_SSE; //Skl_IDct16_SSE;
			if (!cpu.ssemmx)
			{
				IDCT_Flag = IDCT_MMX;
				idctFunc = MMX_IDCT;
			}
			break;

		case IDCT_SIMPLEIDCT:
			idctFunc = simple_idct_mmx;
			if (!cpu.ssemmx)
			{
				IDCT_Flag = IDCT_MMX;
				idctFunc = MMX_IDCT;
			}
			break;
	}

	File_Flag = 0;
	_lseeki64(Infile[0], 0, SEEK_SET);
	Initialize_Buffer();

	do
	{
		if (Fault_Flag == OUT_OF_BITS) return 0;
		next_start_code();
		code = Get_Bits(32);
	}
	while (code!=SEQUENCE_HEADER_CODE);

	sequence_header();

	mb_width = (horizontal_size+15)/16;
	mb_height = progressive_sequence ? (vertical_size+15)/16 : 2*((vertical_size+31)/32);

	QP = (int*)aligned_malloc(sizeof(int)*mb_width*mb_height, 128);

	Coded_Picture_Width = 16 * mb_width;
	Coded_Picture_Height = 16 * mb_height;

	Chroma_Width = (chroma_format==CHROMA444) ? Coded_Picture_Width : Coded_Picture_Width>>1;
	Chroma_Height = (chroma_format!=CHROMA420) ? Coded_Picture_Height : Coded_Picture_Height>>1;

	block_count = ChromaFormat[chroma_format];

	for (i=0; i<8; i++)
	{
		p_block[i] = (short *)aligned_malloc(sizeof(short)*64 + 64, 128);
		block[i]   = (short *)((long)p_block[i] + 64 - (long)p_block[i]%64);
	}

	p_fTempArray = (void *)aligned_malloc(sizeof(float)*128 + 64, 128);
	fTempArray = (void *)((long)p_fTempArray + 64 - (long)p_fTempArray%64);

	for (i=0; i<3; i++)
	{
		if (i==0)
			size = Coded_Picture_Width * Coded_Picture_Height;
		else
			size = Chroma_Width * Chroma_Height;

		backward_reference_frame[i] = (unsigned char*)aligned_malloc(2*size+4096, 128);  //>>> cheap safety bump
		forward_reference_frame[i] = (unsigned char*)aligned_malloc(2*size+4096, 128);
		auxframe[i] = (unsigned char*)aligned_malloc(2*size+4096, 128);
	}

	fscanf(out->VF_File, "YUVRGB_Scale=%d (0:TVScale 1:PCScale)\n", &i);

	if (i)
	{
		RGB_Scale = 0x1000254310002543;
		RGB_Offset = 0x0010001000100010;
		RGB_CBU = 0x0000408D0000408D;
		RGB_CGX = 0xF377E5FCF377E5FC;
		RGB_CRV = 0x0000331300003313;
	}
	else
	{
		RGB_Scale = 0x1000200010002000;
		RGB_Offset = 0x0000000000000000;
		RGB_CBU = 0x000038B4000038B4;
		RGB_CGX = 0xF4FDE926F4FDE926;
		RGB_CRV = 0x00002CDD00002CDD;
	}

	fscanf(out->VF_File, "Luminance_Filter=%d,%d (Gamma, Offset)\n", &i, &j);
	i+=128;

	if (i==128 && j==0) Luminance_Flag = 0;
	else
	{
		Luminance_Flag = 1;
		LumGainMask = ((__int64)i<<48) + ((__int64)i<<32) + ((__int64)i<<16) + (__int64)i;
		LumOffsetMask = ((__int64)j<<48) + ((__int64)j<<32) + ((__int64)j<<16) + (__int64)j;

		nLumSize = Coded_Picture_Width * Coded_Picture_Height;

		// Luminance Gain on old DVD2AVI used to be set at 128 as default
		// But we use the new Luminance Filter, so 128 would equal 0
		i -= 128;

		InitializeLuminanceFilter(i, j);

		lum = (unsigned char*)aligned_malloc(Coded_Picture_Width * Coded_Picture_Height, 128);
	}

	fscanf(out->VF_File, "Clipping=%d,%d,%d,%d (ClipLeft, ClipRight, ClipTop, ClipBottom)\n", 
		   &Clip_Left, &Clip_Right, &Clip_Top, &Clip_Bottom);
	fscanf(out->VF_File, "Aspect_Ratio=%s\n", Aspect_Ratio);
	fscanf(out->VF_File, "Picture_Size=%s\n", &m, &n);

	Clip_Width = Coded_Picture_Width;
	Clip_Height = Coded_Picture_Height;
	CLIP_AREA = HALF_CLIP_AREA = CLIP_STEP = 0;

	LUM_AREA = Coded_Picture_Width * Clip_Height;
	PROGRESSIVE_HEIGHT = (Coded_Picture_Height>>1) - 2;
	INTERLACED_HEIGHT = (Coded_Picture_Height>>2) - 2;
	HALF_WIDTH = Coded_Picture_Width>>1;
	HALF_WIDTH_D8 = (Coded_Picture_Width>>1) - 8;
	DOUBLE_WIDTH = Coded_Picture_Width<<1;

	// these don't seem to be used anywhere anymore  (tritical -- 1/05/2005)
	//u444 = (unsigned char*)aligned_malloc(Coded_Picture_Width * Coded_Picture_Height, 128);
	//v444 = (unsigned char*)aligned_malloc(Coded_Picture_Width * Coded_Picture_Height, 128);

	if (upConv && chroma_format == 1)
	{
		// these are labeled u422 and v422, but I'm only using them as a temporary
		// storage place for YV12 chroma before upsampling to 4:2:2 so that's why its
		// /4 and not /2  --  (tritical - 1/05/2005)
		u422 = (unsigned char*)aligned_malloc((Coded_Picture_Width * Coded_Picture_Height / 4)+2048, 128);
		v422 = (unsigned char*)aligned_malloc((Coded_Picture_Width * Coded_Picture_Height / 4)+2048, 128);
		auxFrame1 = create_YV12PICT(Coded_Picture_Height,Coded_Picture_Width,chroma_format+1);
		auxFrame2 = create_YV12PICT(Coded_Picture_Height,Coded_Picture_Width,chroma_format+1);
	}
	else
	{
		auxFrame1 = create_YV12PICT(Coded_Picture_Height,Coded_Picture_Width,chroma_format);
		auxFrame2 = create_YV12PICT(Coded_Picture_Height,Coded_Picture_Width,chroma_format);
	}
	saved_active = auxFrame1;
	saved_store = auxFrame2;

	fscanf(out->VF_File, "Field_Operation=%d (0:None 1:ForcedFILM 2:RawFrames)\n", &FO_Flag);

	fscanf(out->VF_File, "Frame_Rate=%d\n", &(out->VF_FrameRate));
	fscanf(out->VF_File, "Location=%d,%X,%d,%X\n", &i, &j, &i, &j);

	ntsc = film = top = bottom = gop = mapping = repeat_on = repeat_off = repeat_init = 0;
	HaveRFFs = false;

	fgets(buf, 2047, out->VF_File);
	buf_p = buf;
	while (true)
	{
		sscanf(buf_p, "%x", &type);
		if (type == 0xff)
			break;
		if (type & 0x800)	// GOP line start.
		{
			GOPList[gop] = reinterpret_cast<GOPLIST*>(calloc(1, sizeof(GOPLIST)));
			GOPList[gop]->number = film;
			while (*buf_p++ != ' ');
			sscanf(buf_p, "%d", &(GOPList[gop]->matrix));
			while (*buf_p++ != ' ');
			sscanf(buf_p, "%d", &(GOPList[gop]->file));
			while (*buf_p++ != ' ');
			position = _atoi64(buf_p);
			while (*buf_p++ != ' ');
			sscanf(buf_p, "%d %d", &vob_id, &cell_id);
			while (*buf_p++ != ' ');
			while (*buf_p++ != ' ');
			GOPList[gop]->position = position;
			GOPList[gop]->closed = (type & 0x400) ? 1 : 0;
			GOPList[gop]->progressive = (type & 0x200) ? 1 : 0;
			gop++;

			sscanf(buf_p, "%x", &type);
			tff = (type & 0x2) >> 1;
			if (FO_Flag == FO_RAW)
				rff = 0;
			else
				rff = type & 0x1;
		}
		else	// P, B frame
		{
			tff = (type & 0x2) >> 1;
			if (FO_Flag == FO_RAW)
				rff = 0;
			else
				rff = type & 0x1;
		}
		if (FO_Flag != FO_FILM && FO_Flag != FO_RAW && rff) HaveRFFs = true;

		if (!film)
		{
			if (tff)
				Field_Order = 1;
			else
				Field_Order = 0;
		}

		if (FO_Flag==FO_FILM)
		{
			if (rff)
				repeat_on++;
			else
				repeat_off++;

			if (repeat_init)
			{
				if (repeat_off-repeat_on == 5)
				{
					repeat_on = repeat_off = 0;
				}
				else
				{
					FrameList[mapping].top = FrameList[mapping].bottom = film;
					mapping ++;
				}

				if (repeat_on-repeat_off == 5)
				{
					repeat_on = repeat_off = 0;
					FrameList[mapping].top = FrameList[mapping].bottom = film;
					mapping ++;
				}
			}
			else
			{
				if (repeat_off-repeat_on == 3)
				{
					repeat_on = repeat_off = 0;
					repeat_init = 1;
				}
				else
				{
					FrameList[mapping].top = FrameList[mapping].bottom = film;
					mapping ++;
				}

				if (repeat_on-repeat_off == 3)
				{
					repeat_on = repeat_off = 0;
					repeat_init = 1;

					FrameList[mapping].top = FrameList[mapping].bottom = film;
					mapping ++;
				}
			}
		}
		else
		{
			if (top)
			{
				FrameList[ntsc].bottom = film;
				ntsc ++;
				FrameList[ntsc].top = film;
			}
			else if (bottom)
			{
				FrameList[ntsc].top = film;
				ntsc ++;
				FrameList[ntsc].bottom = film;
			}
			else
			{
				FrameList[ntsc].top = film;
				FrameList[ntsc].bottom = film;
				ntsc ++;
			}

			if (rff)
			{
				if (tff)
				{
					FrameList[ntsc].top = film;
					top = 1;
				}
				else
				{
					FrameList[ntsc].bottom = film;
					bottom = 1;
				}

				if (top && bottom)
				{
					top = bottom = 0;
					ntsc ++;
				}
			}
		}

		FrameList[film].pct = (unsigned char)((type & 0x30) >> 4);
		FrameList[film].pf = (unsigned char)((type & 0x40) >> 6);

		// Remember if this encoded frame requires the previous GOP to be decoded.
		// The previous GOP is required if DVD2AVI has marked it as such.
		if (!(type & 0x80))
			DirectAccess[film] = 0;
		else
			DirectAccess[film] = 1;

		film++;

		// Move to the next flags digit or get the next line.
		while (*buf_p != '\n' && *buf_p != ' ') buf_p++;
		if (*buf_p == '\n')
		{
			fgets(buf, 2047, out->VF_File);
			buf_p = buf;
		}
		else buf_p++;
	}
// dprintf("gop = %d, film = %d, ntsc = %d\n", gop, film, ntsc);
	out->VF_GOPLimit = gop;

	if (FO_Flag==FO_FILM)
	{
		while (FrameList[mapping-1].top >= film)
			mapping--;

		out->VF_FrameLimit = mapping;
	}
	else
	{
		while ((FrameList[ntsc-1].top >= film) || (FrameList[ntsc-1].bottom >= film))
			ntsc--;

		out->VF_FrameLimit = ntsc;
	}

	// Count the number of nondecodable frames at the start of the clip
	// (due to an open GOP). This will be used to avoid displaying these
	// bad frames.
	File_Flag = 0;
	_lseeki64(Infile[File_Flag], GOPList[0]->position, SEEK_SET);
	Initialize_Buffer();

	closed_gop = -1;
	BadStartingFrames = 0;
	while (true)
	{
		Get_Hdr();
		if (picture_coding_type == I_TYPE) break;
	}
	if (closed_gop != 1)
	{
		// Leading B frames are non-decodable.
		while (true)
		{
			Get_Hdr();
			if (picture_coding_type != B_TYPE) break;
			BadStartingFrames++;
		}
		// Frames pulled down from non-decodable frames are non-decodable.
		if (BadStartingFrames)
		{
			i = 0;
			while (true)
			{
				if ((FrameList[i].top > BadStartingFrames - 1) &&
					(FrameList[i].bottom > BadStartingFrames - 1))
					break;
				i++;
			}
			BadStartingFrames = i;
		}
	}
	return 1;
}

Private Declare Function dll_GetRGBFrame Lib "DGDecode.dll" Alias "_getRGBFrame_SC@4" (ByVal lngFrameNum As Long) As Long
Private Declare Function dll_OpenMPEG2 Lib "DGDecode.dll" Alias "_openMPEG2Source_SC@4" (ByVal strFileName As String) As Long
Private Declare Function dll_CloseMPEG2 Lib "DGDecode.dll" Alias "_closeVideo_SC@0" () As Long
Private Declare Function dll_GetFrame Lib "DGDecode.dll" Alias "_getFrame_SC@4" (ByVal lngFrameNum As Long) As Long