Ejemplo n.º 1
0
        private static IEnumerable <IFdsBlock> DumpFast(FamicomDumperConnection dumper, bool dumpHiddenFiles = false, bool printDiskInfo = false)
        {
            Console.Write($"Reading disk... ");
            var blocks = dumper.ReadFdsBlocks().ToArray();

            if (blocks.Length == 0)
            {
                throw new IOException("Invalid disk info block");
            }
            if (!blocks[0].IsValid)
            {
                throw new IOException($"Invalid disk info block type");
            }
            if (!blocks[0].CrcOk)
            {
                throw new IOException($"Invalid CRC on disk info block");
            }
            if (printDiskInfo)
            {
                PrintDiskHeaderInfo(blocks[0] as FdsBlockDiskInfo);
            }
            if (blocks.Length == 1)
            {
                throw new IOException("Invalid file amount block");
            }
            if (!blocks[1].IsValid)
            {
                throw new IOException($"Invalid file amount block type");
            }
            if (!blocks[1].CrcOk)
            {
                throw new IOException($"Invalid CRC on file amount block");
            }
            Console.WriteLine($"Done");
            var fileAmount = (blocks[1] as FdsBlockFileAmount).FileAmount;

            if (printDiskInfo)
            {
                Console.WriteLine($"Number of non-hidden files: {fileAmount}");
            }

            // Check files and print info
            int validBlocks = 2 + fileAmount * 2;

            for (int blockNumber = 2; blockNumber < (dumpHiddenFiles ? blocks.Length : (2 + fileAmount * 2)); blockNumber++)
            {
                var block = blocks[blockNumber];
                if (!block.IsValid)
                {
                    if (blocks.Length < 2 + fileAmount * 2)
                    {
                        throw new IOException($"Invalid block #{blockNumber} (file #{(blockNumber - 2) / 2}) type");
                    }
                    else
                    {
                        if (printDiskInfo)
                        {
                            Console.WriteLine($"Invalid block #{blockNumber}, it's not hidden file, aboritng");
                        }
                        validBlocks = blockNumber;
                        break;
                    }
                }
                if (!block.CrcOk)
                {
                    if (blocks.Length < 2 + fileAmount * 2)
                    {
                        throw new IOException($"Invalid CRC on block #{blockNumber} (file #{(blockNumber - 2) / 2})");
                    }
                    else
                    {
                        if (printDiskInfo)
                        {
                            Console.WriteLine($"Invalid CRC on block #{blockNumber}, it's not hidden file, aboritng");
                        }
                        validBlocks = blockNumber;
                        break;
                    }
                }
                if ((blockNumber % 2) == 0)
                {
                    if (printDiskInfo)
                    {
                        Console.WriteLine($"File #{(blockNumber - 2) / 2}/{fileAmount}:");
                        PrintFileHeaderInfo(block as FdsBlockFileHeader);
                    }
                }
            }
            if (blocks.Length < 2 + fileAmount * 2)
            {
                throw new IOException($"Only {(blocks.Length - 2) / 2} of {fileAmount} valid files received");
            }
            if (dumpHiddenFiles && printDiskInfo)
            {
                Console.WriteLine($"Number of hidden files: {(blocks.Length - 2) / 2 - fileAmount}");
            }
            return(blocks.Take(validBlocks));
        }
Ejemplo n.º 2
0
        private static IEnumerable <IFdsBlock> DumpSlow(FamicomDumperConnection dumper, bool dumpHiddenFiles = false, bool printDiskInfo = false)
        {
            var  blocks      = new List <IFdsBlock>();
            byte blockNumber = 0;

            while (true)
            {
                switch (blockNumber)
                {
                case 0:
                    Console.Write("Reading disk info block... ");
                    break;

                case 1:
                    Console.Write("Reading file amount block... ");
                    break;

                default:
                    if ((blockNumber % 2) == 0)
                    {
                        Console.Write($"Reading file #{(blockNumber - 2) / 2}/{(blocks[1] as FdsBlockFileAmount).FileAmount} header block... ");
                    }
                    else
                    {
                        Console.Write($"Reading file #{(blockNumber - 2) / 2}/{(blocks[1] as FdsBlockFileAmount).FileAmount} data block... ");
                    }
                    break;
                }
                var fdsData = dumper.ReadFdsBlocks(blockNumber, 1);
                if (fdsData.Length == 0)
                {
                    if (blocks.Count > 2 && blocks.Count >= 2 + (blocks[1] as FdsBlockFileAmount).FileAmount * 2)
                    {
                        Console.WriteLine("Invalid block, it's not hidden file, aboritng");
                        break;
                    }
                    throw new IOException($"Invalid block #{blockNumber} (file #{(blockNumber - 2) / 2})");
                }
                var block = fdsData[0];
                if (!block.IsValid)
                {
                    switch (blockNumber)
                    {
                    case 0:
                        throw new IOException($"Invalid disk info block");

                    case 1:
                        throw new IOException($"Invalid file amount block");
                    }
                    if (blocks.Count >= 2 + (blocks[1] as FdsBlockFileAmount).FileAmount * 2)
                    {
                        Console.WriteLine("Invalid block, it's not hidden file, abortitng");
                        break;
                    }
                    else
                    {
                        // Fatal error if bad block ID on non-hidden file
                        throw new IOException($"Invalid block #{blockNumber} (file #{(blockNumber - 2) / 2}) type");
                    }
                }
                if (!block.CrcOk)
                {
                    switch (blockNumber)
                    {
                    case 0:
                        throw new IOException($"Invalid CRC on disk info block");

                    case 1:
                        throw new IOException($"Invalid CRC on file amount block");
                    }
                    if (blocks.Count < 2 + (blocks[1] as FdsBlockFileAmount).FileAmount * 2)
                    {
                        // Fatal error if bad CRC on non-hidden file
                        throw new IOException($"Invalid CRC on block #{blockNumber} (file #{(blockNumber - 2) / 2})");
                    }
                    else
                    {
                        Console.WriteLine("Invalid CRC, it's not hidden file, abortitng");
                        break;
                    }
                }
                blocks.AddRange(fdsData);
                Console.WriteLine($"OK");
                // Some info
                if (printDiskInfo)
                {
                    switch (blockNumber)
                    {
                    case 0:
                        PrintDiskHeaderInfo(block as FdsBlockDiskInfo);
                        break;

                    case 1:
                        Console.WriteLine($"Number of non-hidden files: {(block as FdsBlockFileAmount).FileAmount}");
                        break;

                    default:
                        if ((blockNumber % 2) == 0)
                        {
                            Console.WriteLine($"File #{(blockNumber - 2) / 2}:");
                            PrintFileHeaderInfo(block as FdsBlockFileHeader);
                        }
                        break;
                    }
                }
                // Abort if end of head meet
                if (block.EndOfHeadMeet)
                {
                    Console.WriteLine("End of head meet, aborting");
                    break;
                }
                // Abort if last file dumped
                if (!dumpHiddenFiles && (blocks.Count >= 2) && (blocks.Count >= 2 + (blocks[1] as FdsBlockFileAmount).FileAmount * 2))
                {
                    break;
                }
                blockNumber++;
            }
            if (dumpHiddenFiles)
            {
                Console.WriteLine($"Number of hidden files: {(blocks.Count - 2) / 2 - (blocks[1] as FdsBlockFileAmount).FileAmount}");
            }
            return(blocks);
        }