コード例 #1
0
ファイル: SynthUtils.cs プロジェクト: Asnivor/DiscSN
        /// <summary>
        /// Synthesizes a data sector header
        /// </summary>
        public static void SectorHeader(byte[] buffer16, int offset, int LBA, byte mode)
        {
            buffer16[offset + 0] = 0x00;
            for (int i = 1; i < 11; i++)
            {
                buffer16[offset + i] = 0xFF;
            }
            buffer16[offset + 11] = 0x00;
            Timestamp ts = new Timestamp(LBA + 150);

            buffer16[offset + 12] = BCD2.IntToBCD(ts.MIN);
            buffer16[offset + 13] = BCD2.IntToBCD(ts.SEC);
            buffer16[offset + 14] = BCD2.IntToBCD(ts.FRAC);
            buffer16[offset + 15] = mode;
        }
コード例 #2
0
ファイル: CUE_Load.cs プロジェクト: red031000/tpp-BizHawk2
        void EmitRawTOCEntry(CompiledCueTrack cct)
        {
            SubchannelQ toc_sq = new SubchannelQ();
            //absent some kind of policy for how to set it, this is a safe assumption:
            byte toc_ADR = 1;

            toc_sq.SetStatus(toc_ADR, (EControlQ)(int)cct.Flags);
            toc_sq.q_tno.BCDValue = 0;             //kind of a little weird here.. the track number becomes the 'point' and put in the index instead. 0 is the track number here.
            toc_sq.q_index        = BCD2.FromDecimal(cct.Number);
            //not too sure about these yet
            toc_sq.min          = BCD2.FromDecimal(0);
            toc_sq.sec          = BCD2.FromDecimal(0);
            toc_sq.frame        = BCD2.FromDecimal(0);
            toc_sq.AP_Timestamp = OUT_Disc._Sectors.Count;
            OUT_Disc.RawTOCEntries.Add(new RawTOCEntry {
                QData = toc_sq
            });
        }
コード例 #3
0
        public void Run()
        {
            //TODO: encode_mode2_form2_sector

            var leadoutTs        = Disc.TOC.LeadoutLBA;
            var lastTrackTOCItem = Disc.TOC.TOCItems[Disc.TOC.LastRecordedTrackNumber];             //NOTE: in case LastRecordedTrackNumber is al ie, this will malfunction

            //leadout flags.. let's set them the same as the last track.
            //THIS IS NOT EXACTLY THE SAME WAY MEDNAFEN DOES IT
            EControlQ leadoutFlags = lastTrackTOCItem.Control;

            //TODO - needs to be encoded as a certain mode (mode 2 form 2 for psx... i guess...)

            for (int i = 0; i < Length; i++)
            {
                //var se = new SectorEntry(sz);
                //Disc.Sectors.Add(se);
                SubchannelQ sq = new SubchannelQ();

                int track_relative_msf = i;
                sq.min   = BCD2.FromDecimal(new Timestamp(track_relative_msf).MIN);
                sq.sec   = BCD2.FromDecimal(new Timestamp(track_relative_msf).SEC);
                sq.frame = BCD2.FromDecimal(new Timestamp(track_relative_msf).FRAC);

                int absolute_msf = i + leadoutTs;
                sq.ap_min   = BCD2.FromDecimal(new Timestamp(absolute_msf + 150).MIN);
                sq.ap_sec   = BCD2.FromDecimal(new Timestamp(absolute_msf + 150).SEC);
                sq.ap_frame = BCD2.FromDecimal(new Timestamp(absolute_msf + 150).FRAC);

                sq.q_tno.DecimalValue   = 0xAA;               //special value for leadout
                sq.q_index.DecimalValue = 1;

                byte ADR = 1;
                sq.SetStatus(ADR, leadoutFlags);

                //TODO - actually stash the subQ
            }
        }
コード例 #4
0
        public void Run()
        {
            using (var fs = File.OpenRead(IN_Path))
            {
                BinaryReader br  = new BinaryReader(fs);
                string       sig = br.ReadStringFixedAscii(4);
                if (sig != "SBI\0")
                {
                    throw new SBIParseException("Missing magic number");
                }

                SubQPatchData ret   = new SubQPatchData();
                List <short>  bytes = new List <short>();

                //read records until done
                for (;;)
                {
                    //graceful end
                    if (fs.Position == fs.Length)
                    {
                        break;
                    }

                    if (fs.Position + 4 > fs.Length)
                    {
                        throw new SBIParseException("Broken record");
                    }
                    var m  = BCD2.BCDToInt(br.ReadByte());
                    var s  = BCD2.BCDToInt(br.ReadByte());
                    var f  = BCD2.BCDToInt(br.ReadByte());
                    var ts = new Timestamp(m, s, f);
                    ret.ABAs.Add(ts.Sector);
                    int type = br.ReadByte();
                    switch (type)
                    {
                    case 1:     //Q0..Q9
                        if (fs.Position + 10 > fs.Length)
                        {
                            throw new SBIParseException("Broken record");
                        }
                        for (int i = 0; i <= 9; i++)
                        {
                            bytes.Add(br.ReadByte());
                        }
                        for (int i = 10; i <= 11; i++)
                        {
                            bytes.Add(-1);
                        }
                        break;

                    case 2:     //Q3..Q5
                        if (fs.Position + 3 > fs.Length)
                        {
                            throw new SBIParseException("Broken record");
                        }
                        for (int i = 0; i <= 2; i++)
                        {
                            bytes.Add(-1);
                        }
                        for (int i = 3; i <= 5; i++)
                        {
                            bytes.Add(br.ReadByte());
                        }
                        for (int i = 6; i <= 11; i++)
                        {
                            bytes.Add(-1);
                        }
                        break;

                    case 3:     //Q7..Q9
                        if (fs.Position + 3 > fs.Length)
                        {
                            throw new SBIParseException("Broken record");
                        }
                        for (int i = 0; i <= 6; i++)
                        {
                            bytes.Add(-1);
                        }
                        for (int i = 7; i <= 9; i++)
                        {
                            bytes.Add(br.ReadByte());
                        }
                        for (int i = 10; i <= 11; i++)
                        {
                            bytes.Add(-1);
                        }
                        break;

                    default:
                        throw new SBIParseException("Broken record");
                    }
                }

                ret.subq = bytes.ToArray();

                OUT_Data = ret;
            }
        }
コード例 #5
0
ファイル: CUE_Load.cs プロジェクト: red031000/tpp-BizHawk2
        public void Run()
        {
            //params
            var compiled = IN_CompileJob;
            var context  = compiled.IN_CueContext;

            OUT_Disc = new Disc();

            //generation state
            int      curr_index;
            int      curr_blobIndex  = -1;
            int      curr_blobMSF    = -1;
            BlobInfo curr_blobInfo   = null;
            long     curr_blobOffset = -1;

            //mount all input files
            MountBlobs();

            //unhappily, we cannot determine the length of all the tracks without knowing the length of the files
            //now that the files are mounted, we can figure the track lengths
            AnalyzeTracks();

            //loop from track 1 to 99
            //(track 0 isnt handled yet, that's way distant work)
            for (int t = 1; t < TrackInfos.Count; t++)
            {
                TrackInfo        ti  = TrackInfos[t];
                CompiledCueTrack cct = ti.CompiledCueTrack;

                //---------------------------------
                //setup track pregap processing
                //per "Example 05" on digitalx.org, pregap can come from index specification and pregap command
                int specifiedPregapLength = cct.PregapLength.Sector;
                int impliedPregapLength   = cct.Indexes[1].FileMSF.Sector - cct.Indexes[0].FileMSF.Sector;
                int totalPregapLength     = specifiedPregapLength + impliedPregapLength;

                //from now on we'll track relative timestamp and increment it continually
                int relMSF = -totalPregapLength;

                //read more at policies declaration
                //if (!context.DiscMountPolicy.CUE_PauseContradictionModeA)
                //  relMSF += 1;
                //---------------------------------


                //---------------------------------
                //generate sectors for this track.

                //advance to the next file if needed
                if (curr_blobIndex != cct.BlobIndex)
                {
                    curr_blobIndex  = cct.BlobIndex;
                    curr_blobOffset = 0;
                    curr_blobMSF    = 0;
                    curr_blobInfo   = BlobInfos[curr_blobIndex];
                }

                //work until the next track is reached, or the end of the current file is reached, depending on the track type
                curr_index = 0;
                for (; ;)
                {
                    bool trackDone   = false;
                    bool generateGap = false;

                    if (specifiedPregapLength > 0)
                    {
                        //if burning through a specified pregap, count it down
                        generateGap = true;
                        specifiedPregapLength--;
                    }
                    else
                    {
                        //if burning through the file, select the appropriate index by inspecting the next index and seeing if we've reached it
                        for (; ;)
                        {
                            if (curr_index == cct.Indexes.Count - 1)
                            {
                                break;
                            }
                            if (curr_blobMSF >= cct.Indexes[curr_index + 1].FileMSF.Sector)
                            {
                                curr_index++;
                                if (curr_index == 1)
                                {
                                    //WE ARE NOW AT INDEX 1: generate the RawTOCEntry for this track
                                    EmitRawTOCEntry(cct);
                                }
                            }
                            else
                            {
                                break;
                            }
                        }
                    }

                    //select the track type for the subQ
                    //it's obviously the same as the main track type usually, but during a pregap it can be different
                    TrackInfo qTrack  = ti;
                    int       qRelMSF = relMSF;
                    if (curr_index == 0)
                    {
                        //tweak relMSF due to ambiguity/contradiction in yellowbook docs
                        if (!context.DiscMountPolicy.CUE_PregapContradictionModeA)
                        {
                            qRelMSF++;
                        }

                        //[IEC10149] says there's two "intervals" of a pregap.
                        //mednafen's pseudocode interpretation of this:
                        //if this is a data track and the previous track was not data, the last 150 sectors of the pregap match this track and the earlier sectors (at least 75) math the previous track
                        //I agree, so let's do it that way
                        if (t != 1 && cct.TrackType != CueTrackType.Audio && TrackInfos[t - 1].CompiledCueTrack.TrackType == CueTrackType.Audio)
                        {
                            if (relMSF < -150)
                            {
                                qTrack = TrackInfos[t - 1];
                            }
                        }
                    }

                    //generate the right kind of sector synth for this track
                    SS_Base ss = null;
                    if (generateGap)
                    {
                        var ss_gap = new SS_Gap();
                        ss_gap.TrackType = qTrack.CompiledCueTrack.TrackType;
                        ss = ss_gap;
                    }
                    else
                    {
                        int sectorSize = int.MaxValue;
                        switch (qTrack.CompiledCueTrack.TrackType)
                        {
                        case CueTrackType.Audio:
                        case CueTrackType.CDI_2352:
                        case CueTrackType.Mode1_2352:
                        case CueTrackType.Mode2_2352:
                            ss         = new SS_2352();
                            sectorSize = 2352;
                            break;

                        case CueTrackType.Mode1_2048:
                            ss         = new SS_Mode1_2048();
                            sectorSize = 2048;
                            break;

                        default:
                        case CueTrackType.Mode2_2336:
                            throw new InvalidOperationException($"Not supported: {cct.TrackType}");
                        }

                        ss.Blob          = curr_blobInfo.Blob;
                        ss.BlobOffset    = curr_blobOffset;
                        curr_blobOffset += sectorSize;
                        curr_blobMSF++;
                    }

                    ss.Policy = context.DiscMountPolicy;

                    //setup subQ
                    byte ADR = 1;                     //absent some kind of policy for how to set it, this is a safe assumption:
                    ss.sq.SetStatus(ADR, (EControlQ)(int)qTrack.CompiledCueTrack.Flags);
                    ss.sq.q_tno        = BCD2.FromDecimal(cct.Number);
                    ss.sq.q_index      = BCD2.FromDecimal(curr_index);
                    ss.sq.AP_Timestamp = OUT_Disc._Sectors.Count;
                    ss.sq.Timestamp    = qRelMSF;

                    //setup subP
                    if (curr_index == 0)
                    {
                        ss.Pause = true;
                    }

                    OUT_Disc._Sectors.Add(ss);
                    relMSF++;

                    if (cct.IsFinalInFile)
                    {
                        //sometimes, break when the file is exhausted
                        if (curr_blobOffset >= curr_blobInfo.Length)
                        {
                            trackDone = true;
                        }
                    }
                    else
                    {
                        //other times, break when the track is done
                        //(this check is safe because it's not the final track overall if it's not the final track in a file)
                        if (curr_blobMSF >= TrackInfos[t + 1].CompiledCueTrack.Indexes[0].FileMSF.Sector)
                        {
                            trackDone = true;
                        }
                    }

                    if (trackDone)
                    {
                        break;
                    }
                }

                //---------------------------------
                //gen postgap sectors
                int specifiedPostgapLength = cct.PostgapLength.Sector;
                for (int s = 0; s < specifiedPostgapLength; s++)
                {
                    var ss = new SS_Gap();
                    ss.TrackType = cct.TrackType;                     //TODO - old track type in some < -150 cases?

                    //-subq-
                    byte ADR = 1;
                    ss.sq.SetStatus(ADR, (EControlQ)(int)cct.Flags);
                    ss.sq.q_tno        = BCD2.FromDecimal(cct.Number);
                    ss.sq.q_index      = BCD2.FromDecimal(curr_index);
                    ss.sq.AP_Timestamp = OUT_Disc._Sectors.Count;
                    ss.sq.Timestamp    = relMSF;

                    //-subP-
                    //always paused--is this good enough?
                    ss.Pause = true;

                    OUT_Disc._Sectors.Add(ss);
                    relMSF++;
                }
            }             //end track loop


            //add RawTOCEntries A0 A1 A2 to round out the TOC
            var TOCMiscInfo = new Synthesize_A0A1A2_Job {
                IN_FirstRecordedTrackNumber = IN_CompileJob.OUT_CompiledDiscInfo.FirstRecordedTrackNumber,
                IN_LastRecordedTrackNumber  = IN_CompileJob.OUT_CompiledDiscInfo.LastRecordedTrackNumber,
                IN_Session1Format           = IN_CompileJob.OUT_CompiledDiscInfo.SessionFormat,
                IN_LeadoutTimestamp         = OUT_Disc._Sectors.Count
            };

            TOCMiscInfo.Run(OUT_Disc.RawTOCEntries);

            //TODO - generate leadout, or delegates at least

            //blech, old crap, maybe
            //OUT_Disc.Structure.Synthesize_TOCPointsFromSessions();

            //FinishLog();
        } //Run()
コード例 #6
0
        private void RunMednaDisc()
        {
            var disc = new Disc();

            OUT_Disc = disc;

            //create a MednaDisc and give it to the disc for ownership
            var md = new MednaDisc(IN_FromPath);

            disc.DisposableResources.Add(md);

            //"length of disc" for BizHawk's purposes (NOT a robust concept!) is determined by beginning of leadout track
            var m_leadoutTrack = md.TOCTracks[100];
            int nSectors       = (int)m_leadoutTrack.lba;

            //make synth param memos
            disc.SynthParams.MednaDisc = md;

            //this is the sole sector synthesizer we'll need
            var synth = new SS_MednaDisc();

            OUT_Disc.SynthProvider = new SimpleSectorSynthProvider {
                SS = synth
            };

            //ADR (q-Mode) is necessarily 0x01 for a RawTOCEntry
            const int kADR            = 1;
            const int kUnknownControl = 0;

            //mednafen delivers us what is essentially but not exactly (or completely) a TOCRaw.
            //we need to synth RawTOCEntries from this and then turn it into a proper TOCRaw
            //when coming from mednafen, there are 101 entries.
            //entry[0] is placeholder junk, not to be used
            //entry[100] is the leadout track (A0)
            //A1 and A2 are in the form of FirstRecordedTrackNumber and LastRecordedTrackNumber
            for (int i = 1; i < 101; i++)
            {
                var m_te = md.TOCTracks[i];

                //don't add invalid (absent) items
                if (!m_te.Valid)
                {
                    continue;
                }

                var m_ts = new Timestamp((int)m_te.lba + 150);                 //these are supposed to be absolute timestamps

                var q = new SubchannelQ
                {
                    q_status = SubchannelQ.ComputeStatus(kADR, (EControlQ)m_te.control),
                    q_tno    = BCD2.FromDecimal(0), //unknown with mednadisc
                    q_index  = BCD2.FromDecimal(i),
                    min      = BCD2.FromDecimal(0), //unknown with mednadisc
                    sec      = BCD2.FromDecimal(0), //unknown with mednadisc
                    frame    = BCD2.FromDecimal(0), //unknown with mednadisc
                    zero     = 0,                   //unknown with mednadisc
                    ap_min   = BCD2.FromDecimal(m_ts.MIN),
                    ap_sec   = BCD2.FromDecimal(m_ts.SEC),
                    ap_frame = BCD2.FromDecimal(m_ts.FRAC),
                    q_crc    = 0                  //meaningless
                };

                //a special fixup: mednafen's entry 100 is the lead-out track, so change it into the A2 raw toc entry
                if (i == 100)
                {
                    q.q_index.BCDValue = 0xA2;
                }

                disc.RawTOCEntries.Add(new RawTOCEntry {
                    QData = q
                });
            }

            // synth A0 and A1 entries (indicating first and last recorded tracks and also session type)
            var qA0 = new SubchannelQ
            {
                q_status = SubchannelQ.ComputeStatus(kADR, kUnknownControl),
                q_tno    = BCD2.FromDecimal(0), //unknown with mednadisc
                q_index  = BCD2.FromBCD(0xA0),
                min      = BCD2.FromDecimal(0), //unknown with mednadisc
                sec      = BCD2.FromDecimal(0), //unknown with mednadisc
                frame    = BCD2.FromDecimal(0), //unknown with mednadisc
                zero     = 0,                   //unknown with mednadisc
                ap_min   = BCD2.FromDecimal(md.TOC.first_track),
                ap_sec   = BCD2.FromDecimal(md.TOC.disc_type),
                ap_frame = BCD2.FromDecimal(0),
                q_crc    = 0,              //meaningless
            };

            disc.RawTOCEntries.Add(new RawTOCEntry {
                QData = qA0
            });
            var qA1 = new SubchannelQ
            {
                q_status = SubchannelQ.ComputeStatus(kADR, kUnknownControl),
                q_tno    = BCD2.FromDecimal(0), //unknown with mednadisc
                q_index  = BCD2.FromBCD(0xA1),
                min      = BCD2.FromDecimal(0), //unknown with mednadisc
                sec      = BCD2.FromDecimal(0), //unknown with mednadisc
                frame    = BCD2.FromDecimal(0), //unknown with mednadisc
                zero     = 0,                   //unknown with mednadisc
                ap_min   = BCD2.FromDecimal(md.TOC.last_track),
                ap_sec   = BCD2.FromDecimal(0),
                ap_frame = BCD2.FromDecimal(0),
                q_crc    = 0,              //meaningless
            };

            disc.RawTOCEntries.Add(new RawTOCEntry {
                QData = qA1
            });
        }
コード例 #7
0
        /// <summary>
        /// Loads a CCD at the specified path to a Disc object
        /// </summary>
        public Disc LoadCCDToDisc(string ccdPath, DiscMountPolicy IN_DiscMountPolicy)
        {
            var loadResults = LoadCCDPath(ccdPath);

            if (!loadResults.Valid)
            {
                return(null);
            }
            //throw loadResults.FailureException;

            Disc disc = new Disc();

            IBlob imgBlob = null, subBlob = null;
            long  imgLen = -1, subLen;

            //mount the IMG file
            //first check for a .ecm in place of the img
            var imgPath = loadResults.ImgPath;

            if (!File.Exists(imgPath))
            {
                var ecmPath = Path.ChangeExtension(imgPath, ".img.ecm");
                if (File.Exists(ecmPath))
                {
                    if (Disc.Blob_ECM.IsECM(ecmPath))
                    {
                        var ecm = new Disc.Blob_ECM();
                        ecm.Load(ecmPath);
                        imgBlob = ecm;
                        imgLen  = ecm.Length;
                    }
                }
            }
            if (imgBlob == null)
            {
                if (!File.Exists(loadResults.ImgPath))
                {
                    throw new CCDParseException("Malformed CCD format: nonexistent IMG file!");
                }
                var imgFile = new Disc.Blob_RawFile()
                {
                    PhysicalPath = loadResults.ImgPath
                };
                imgLen  = imgFile.Length;
                imgBlob = imgFile;
            }
            disc.DisposableResources.Add(imgBlob);

            //mount the SUB file
            if (!File.Exists(loadResults.SubPath))
            {
                throw new CCDParseException("Malformed CCD format: nonexistent SUB file!");
            }
            var subFile = new Disc.Blob_RawFile()
            {
                PhysicalPath = loadResults.SubPath
            };

            subBlob = subFile;
            disc.DisposableResources.Add(subBlob);
            subLen = subFile.Length;

            //quick integrity check of file sizes
            if (imgLen % 2352 != 0)
            {
                throw new CCDParseException("Malformed CCD format: IMG file length not multiple of 2352");
            }
            int NumImgSectors = (int)(imgLen / 2352);

            if (subLen != NumImgSectors * 96)
            {
                throw new CCDParseException("Malformed CCD format: SUB file length not matching IMG");
            }

            var ccdf = loadResults.ParsedCCDFile;

            //the only instance of a sector synthesizer we'll need
            SS_CCD synth = new SS_CCD();

            //generate DiscTOCRaw items from the ones specified in the CCD file
            //TODO - range validate these (too many truncations to byte)
            disc.RawTOCEntries = new List <RawTOCEntry>();
            foreach (var entry in ccdf.TOCEntries)
            {
                BCD2 tno, ino;

                //this should actually be zero. im not sure if this is stored as BCD2 or not
                tno = BCD2.FromDecimal(entry.TrackNo);

                //these are special values.. I think, taken from this:
                //http://www.staff.uni-mainz.de/tacke/scsi/SCSI2-14.html
                //the CCD will contain Points as decimal values except for these specially converted decimal values which should stay as BCD.
                //Why couldn't they all be BCD? I don't know. I guess because BCD is inconvenient, but only A0 and friends have special meaning. It's confusing.
                ino = BCD2.FromDecimal(entry.Point);
                if (entry.Point == 0xA0)
                {
                    ino.BCDValue = 0xA0;
                }
                else if (entry.Point == 0xA1)
                {
                    ino.BCDValue = 0xA1;
                }
                else if (entry.Point == 0xA2)
                {
                    ino.BCDValue = 0xA2;
                }

                var q = new SubchannelQ
                {
                    q_status = SubchannelQ.ComputeStatus(entry.ADR, (EControlQ)(entry.Control & 0xF)),
                    q_tno    = tno,
                    q_index  = ino,
                    min      = BCD2.FromDecimal(entry.AMin),
                    sec      = BCD2.FromDecimal(entry.ASec),
                    frame    = BCD2.FromDecimal(entry.AFrame),
                    zero     = (byte)entry.Zero,
                    ap_min   = BCD2.FromDecimal(entry.PMin),
                    ap_sec   = BCD2.FromDecimal(entry.PSec),
                    ap_frame = BCD2.FromDecimal(entry.PFrame),
                    q_crc    = 0, //meaningless
                };

                disc.RawTOCEntries.Add(new RawTOCEntry {
                    QData = q
                });
            }

            //analyze the RAWTocEntries to figure out what type of track track 1 is
            var tocSynth = new Synthesize_DiscTOC_From_RawTOCEntries_Job()
            {
                Entries = disc.RawTOCEntries
            };

            tocSynth.Run();

            //Add sectors for the mandatory track 1 pregap, which isn't stored in the CCD file
            //We reuse some CUE code for this.
            //If we load other formats later we might should abstract this even further (to a synthesizer job)
            //It can't really be abstracted from cue files though due to the necessity of merging this with other track 1 pregaps
            CUE.CueTrackType pregapTrackType = CUE.CueTrackType.Audio;
            if (tocSynth.Result.TOCItems[1].IsData)
            {
                if (tocSynth.Result.Session1Format == SessionFormat.Type20_CDXA)
                {
                    pregapTrackType = CUE.CueTrackType.Mode2_2352;
                }
                else if (tocSynth.Result.Session1Format == SessionFormat.Type10_CDI)
                {
                    pregapTrackType = CUE.CueTrackType.CDI_2352;
                }
                else if (tocSynth.Result.Session1Format == SessionFormat.Type00_CDROM_CDDA)
                {
                    pregapTrackType = CUE.CueTrackType.Mode1_2352;
                }
            }
            for (int i = 0; i < 150; i++)
            {
                var ss_gap = new CUE.SS_Gap()
                {
                    Policy    = IN_DiscMountPolicy,
                    TrackType = pregapTrackType
                };
                disc._Sectors.Add(ss_gap);

                int qRelMSF = i - 150;

                //tweak relMSF due to ambiguity/contradiction in yellowbook docs
                if (!IN_DiscMountPolicy.CUE_PregapContradictionModeA)
                {
                    qRelMSF++;
                }

                //setup subQ
                byte ADR = 1; //absent some kind of policy for how to set it, this is a safe assumption:
                ss_gap.sq.SetStatus(ADR, tocSynth.Result.TOCItems[1].Control);
                ss_gap.sq.q_tno        = BCD2.FromDecimal(1);
                ss_gap.sq.q_index      = BCD2.FromDecimal(0);
                ss_gap.sq.AP_Timestamp = i;
                ss_gap.sq.Timestamp    = qRelMSF;

                //setup subP
                ss_gap.Pause = true;
            }

            //build the sectors:
            //set up as many sectors as we have img/sub for, even if the TOC doesnt reference them
            //(the TOC is unreliable, and the Track records are redundant)
            for (int i = 0; i < NumImgSectors; i++)
            {
                disc._Sectors.Add(synth);
            }

            return(disc);
        }