DIRECTORY Basics, ImagerPixelArray, ImagerPixelArrayDefs, ImagerPixelArrayPrivate, ImagerSample, ImagerTransformation, UnsafeStorage, PrincOps; ImagerPixelArrayImpl: CEDAR PROGRAM IMPORTS Basics, ImagerSample, ImagerTransformation, UnsafeStorage EXPORTS ImagerPixelArray, ImagerPixelArrayDefs ~ BEGIN OPEN ImagerPixelArray, ImagerPixelArrayDefs; PixelArrayImpl: TYPE ~ ImagerPixelArrayPrivate.PixelArrayImpl; PixelArrayImplRep: PUBLIC TYPE ~ ImagerPixelArrayPrivate.PixelArrayImplRep; PixelArrayClass: TYPE ~ ImagerPixelArrayPrivate.PixelArrayClass; PixelArrayClassRep: PUBLIC TYPE ~ ImagerPixelArrayPrivate.PixelArrayClassRep; Error: PUBLIC ERROR[error: ErrorDesc] ~ CODE; GetClass: PUBLIC PROC [pa: PixelArray] RETURNS [ATOM] ~ { class: PixelArrayClass ~ pa.class; RETURN[class.type]; }; MaxSampleValue: PUBLIC PROC [pa: PixelArray, i: NAT] RETURNS [Sample] ~ { class: PixelArrayClass ~ pa.class; RETURN class.MaxSampleValue[pa, i]; }; UnsafeGetSamples: PUBLIC UNSAFE PROC [pa: PixelArray, i: NAT, s, f: INT, samples: UnsafeSamples, count: NAT] ~ TRUSTED { class: PixelArrayClass ~ pa.class; class.UnsafeGetSamples[pa: pa, i: i, s: s, f: f, samples: samples, count: count]; }; bitsPerWord: NAT ~ Basics.bitsPerWord; UnsafeGetBits: PUBLIC UNSAFE PROC [pa: PixelArray, i: NAT, s, f: INT, dst: PrincOps.BitAddress, dstBpl: INTEGER, width, height: CARDINAL, srcFunc: PrincOps.SrcFunc _ null, dstFunc: PrincOps.DstFunc _ null] ~ UNCHECKED { class: PixelArrayClass ~ pa.class; IF class.UnsafeGetBits # NIL THEN class.UnsafeGetBits[pa: pa, i: i, s: s, f: f, dst: dst, dstBpl: dstBpl, width: width, height: height, srcFunc: srcFunc, dstFunc: dstFunc] ELSE { tZone: UNCOUNTED ZONE ~ UnsafeStorage.GetTransientPageUZone[]; bitsPerLine: NAT ~ dstBpl; buf: UnsafeSamples _ tZone.NEW[ImagerSample.RawSamples[width]]; base: LONG POINTER _ dst.word; bit: NAT _ dst.bit; FOR line: NAT IN [0..height) DO UnsafeGetSamples[pa: pa, i: i, s: s+line, f: f, samples: buf, count: width]; ImagerSample.UnsafePutF[samples: buf, count: width, s: 0, f: bit, base: base, wordsPerLine: 0, bitsPerSample: 1, srcFunc: srcFunc, dstFunc: dstFunc]; base _ base + NAT[bit + bitsPerLine] / bitsPerWord; bit _ NAT[bit + bitsPerLine] MOD bitsPerWord ENDLOOP; tZone.FREE[@buf]; }; }; GetSample: PUBLIC PROC [pa: PixelArray, i: NAT, s, f: INT] RETURNS [sample: Sample] ~ { class: PixelArrayClass ~ pa.class; TRUSTED { class.UnsafeGetSamples[pa: pa, i: i, s: s, f: f, samples: LOOPHOLE[LONG[@sample]], count: 1] }; }; GetSamples: PUBLIC PROC [pa: PixelArray, i: NAT, s, f: INT, buffer: SampleBuffer, bi, bj: NAT _ 0, count: NAT] ~ { class: PixelArrayClass ~ pa.class; samples: UnsafeSamples ~ buffer.GetPointer[bi, bj, count]; TRUSTED { class.UnsafeGetSamples[pa: pa, i: i, s: s, f: f, samples: samples, count: count] }; }; GetPixels: PUBLIC PROC [pa: PixelArray, s, f: INT, buffer: SampleBuffer, bj: NAT, count: NAT] ~ { class: PixelArrayClass ~ pa.class; FOR i: NAT IN[0..pa.samplesPerPixel) DO samples: UnsafeSamples ~ buffer.GetPointer[i, bj, count]; TRUSTED { class.UnsafeGetSamples[pa: pa, i: i, s: s, f: f, samples: samples, count: count] }; ENDLOOP; }; extractedClass: PixelArrayClass ~ NEW[PixelArrayClassRep _ [ type: $Extracted, MaxSampleValue: ExtractedMaxSampleValue, UnsafeGetSamples: ExtractedUnsafeGetSamples ]]; ExtractedData: TYPE ~ REF ExtractedDataRep; ExtractedDataRep: TYPE ~ RECORD [ basePA: PixelArray, indices: SEQUENCE samplesPerPixel: NAT OF NAT ]; ExtractedMaxSampleValue: PROC [pa: PixelArray, i: NAT] RETURNS [Sample] ~ { ed: ExtractedData ~ NARROW[pa.data]; RETURN [MaxSampleValue[ed.basePA, ed[i]]]; }; ExtractedUnsafeGetSamples: UNSAFE PROC [pa: PixelArray, i: NAT, s, f: INT, samples: UnsafeSamples, count: NAT] ~ UNCHECKED { ed: ExtractedData ~ NARROW[pa.data]; UnsafeGetSamples[pa: ed.basePA, i: ed[i], s: s, f: f, samples: samples, count: count]; }; Extract: PUBLIC PROC [old: PixelArray, samplesPerPixel: NAT, select: PROC [NAT] RETURNS [NAT]] RETURNS [new: PixelArray] ~ { ed: ExtractedData ~ NEW[ExtractedDataRep[samplesPerPixel]]; ed.basePA _ old; FOR i: NAT IN [0..samplesPerPixel) DO ed[i] _ Basics.BoundsCheck[select[i], old.samplesPerPixel]; ENDLOOP; RETURN[NEW[PixelArrayRep _ [samplesPerPixel: samplesPerPixel, sSize: old.sSize, fSize: old.fSize, m: old.m, class: extractedClass, data: ed]]]; }; joinedClass: PixelArrayClass ~ NEW[PixelArrayClassRep _ [ type: $Joined, MaxSampleValue: JoinedMaxSampleValue, UnsafeGetSamples: JoinedUnsafeGetSamples ]]; JoinedMaxSampleValue: PROC [pa: PixelArray, i: NAT] RETURNS [Sample] ~ { list: LIST OF PixelArray ~ NARROW[pa.data]; k: NAT _ Basics.BoundsCheck[i, pa.samplesPerPixel]; FOR each: LIST OF PixelArray _ list, each.rest UNTIL each=NIL DO slice: PixelArray ~ each.first; IF kKšœžœžœ-˜KK˜Kšœžœ+˜@Kšœžœžœ.˜MK˜Kšœžœžœžœ˜-K˜š Ïnœžœžœžœžœ˜9K˜"Kšžœ ˜K˜K˜—š  œžœžœžœžœ ˜IK˜"Kšžœ˜#K˜K˜—š œžœžœžœžœžœ"žœžœ˜yK˜"KšœQ˜QK˜K˜—šœ žœ˜&K˜—š  œžœžœžœžœžœ%žœžœIž œ˜ÝK˜"KšžœžœžœŒ˜­šžœ˜Kšœž œžœ)˜>Kšœ žœ ˜Kšœžœ!˜?Kšœžœžœ ˜Kšœžœ ˜šžœžœžœ ž˜KšœL˜LK•StartOfExpansion©[samples: ImagerSample.UnsafeSamples, count: NAT, s: NAT _ 0, f: NAT _ 0, base: LONG POINTER, wordsPerLine: NAT, bitsPerSample: ImagerSample.BitsPerSample]šœ•˜•Kšœžœ"˜3Kšœžœžœ ˜,Kšžœ˜—Kšœžœ˜Kšœ˜—K˜K˜—š   œžœžœžœžœžœ˜WK˜"Kšžœ>žœžœ˜jK˜K˜—š  œžœžœžœžœ!žœ žœ˜sK˜"Kšœ:˜:KšžœV˜]K˜K˜—š   œžœžœžœžœ žœ˜bK˜"šžœžœžœž˜'Kšœ9˜9KšžœV˜]Kšžœ˜—K˜K˜—K˜šœ"žœ˜