Ejemplo n.º 1
0
 private static IvffResult CheckBlockFirst(
     Stream stream,
     ref IvCommonCheckWork checkWork,
     int divideSize,
     ref IvCommonBlockHeader workHeader,
     uint blockID)
 {
     return(Ivff.CheckBlockFirst <IvCommonBlockHeader>(stream, out checkWork, divideSize, ref workHeader, ref workHeader, blockID));
 }
Ejemplo n.º 2
0
        private static IvffResult CheckFileBlockFirst(
            Stream stream,
            ref IvaFileHandler ivaHandler,
            BlockOffsetIndex index,
            int divideSize,
            ref IvCommonBlockHeader blockHeader)
        {
            uint blockID = Ivff.BLOCK_ID_TABLE[index];
            uint num     = ivaHandler.CommonHandler.BlockOffsetTable[(int)index];

            stream.Seek((long)num, SeekOrigin.Begin);
            return(Ivff.CheckBlockFirst <IvCommonBlockHeader>(stream, out ivaHandler.CommonHandler.CheckerWork, divideSize, ref blockHeader, ref blockHeader, blockID));
        }
Ejemplo n.º 3
0
        private static IvffResult LoadIvCommonFilehandler(
            Stream stream,
            ref IvCommonFileHandler commonHandler)
        {
            IvffResult          result     = IvffResult.OK;
            int                 num        = 0;
            bool                flag       = true;
            IvCommonBlockHeader workHeader = new IvCommonBlockHeader();

            while (flag)
            {
                result = Ivff.CheckBlockFirst(stream, ref commonHandler.CheckerWork, 0, ref workHeader, 0U);
                if (!Ivff.IsResultError(result))
                {
                    switch (workHeader.BlockID)
                    {
                    case 4281929:
                        if (num != 0)
                        {
                            return(IvffResult.INVALID);
                        }
                        commonHandler.VersionInfofHeader = workHeader;
                        result = Ivff.LoadBlock <IvVersionInfoData>(stream, ref commonHandler.VersionInfo, (long)(commonHandler.VersionInfofHeader.FilePosition + (int)commonHandler.VersionInfofHeader.BlockHeaderSize));
                        if (!Ivff.IsResultError(result))
                        {
                            if (!IvaUtils.IsCompatibleSettingVersion(Ivff.CURRENT_FILE_VERSION, commonHandler.VersionInfo.MinFileVersion))
                            {
                                result = IvffResult.UNCOMPATIBLE;
                                break;
                            }
                            if (commonHandler.VersionInfo.FileSize < 0U || commonHandler.VersionInfo.FileSize > (uint)int.MaxValue)
                            {
                                result = IvffResult.INVALID;
                                break;
                            }
                            if ((long)commonHandler.VersionInfo.FileSize != stream.Length)
                            {
                                result = IvffResult.INVALID;
                                break;
                            }
                            break;
                        }
                        break;

                    case 5264969:
                    case 5527113:
                        return(IvffResult.INVALID);

                    case 5656141:
                    case 1196379203:
                    case 1196379216:
                    case 1230195795:
                    case 1279480653:
                    case 1279611725:
                    case 1280003650:
                    case 1280529238:
                    case 1296520008:
                    case 1314144592:
                    case 1347699024:
                    case 1396855638:
                    case 1397642070:
                    case 1397969750:
                    case 1414547283:
                    case 1414550593:
                    case 1498565971:
                        result = IvffResult.INVALID;
                        break;

                    case 5657430:
                        if (num == 0)
                        {
                            return(IvffResult.INVALID);
                        }
                        commonHandler.CameraInfofHeader = workHeader;
                        result = Ivff.LoadBlock <VisionSensorVersion>(stream, ref commonHandler.CameraVersion, (long)(commonHandler.CameraInfofHeader.FilePosition + (int)commonHandler.CameraInfofHeader.BlockHeaderSize));
                        break;

                    case 1397116738:
                        if (num == 0)
                        {
                            return(IvffResult.INVALID);
                        }
                        commonHandler.BlockOffsetHeader = workHeader;
                        result = Ivff.LoadBlock <uint>(stream, ref commonHandler.BlockOffsetTable, (long)(commonHandler.BlockOffsetHeader.FilePosition + (int)commonHandler.BlockOffsetHeader.BlockHeaderSize));
                        flag   = false;
                        break;

                    default:
                        result = IvffResult.OK;
                        break;
                    }
                    if (!Ivff.IsResultError(result))
                    {
                        try
                        {
                            stream.Seek((long)(workHeader.FilePosition + workHeader.BlockSize), SeekOrigin.Begin);
                        }
                        catch (Exception ex)
                        {
                            break;
                        }
                        ++num;
                    }
                    else
                    {
                        break;
                    }
                }
                else
                {
                    break;
                }
            }
            if (Ivff.IsResultError(result))
            {
                return(IvffResult.FATAL_ERROR);
            }
            return(result);
        }