codeimage.io

STUDIO HAZE · image

Topaz source

Open by house policy. Topaz is our own language.

Topaz 5.21 · 113 files

topaz/src/image_carrier.tpz

Topaz · 16482 B · Original file

1// Image request validation, page planning, and the page rendering entry points.
3import std.bytes { Bytes }
4import std.json
5import ecc { 리드솔로몬보호 }
6import hash { 해시이백오십육 }
7import image_raster { 그림준비하기, 정규피엔지, 조상또는자신 }
8import plan {
9 배열에있음,
10 범위코드,
11 보호길이,
12 이미지계획,
13 이미지배치,
14 이미지배치계산,
15 이미지쪽계획,
16 이미지프로필해시맞음,
17 쪽투영문자열,
18 파일프로그램코드,
19 픽셀글꼴,
21import printers { 인쇄구조검사, 준비된구조 }
22import structure { 구조노드, 구조언어번호, 구조입력, 이미지요청, 이미지요청읽기 }
23import util { 작은값, 큰값 }
25// 이미지 운반체. 큰 래스터는 바이트 배열로 펼치지 않고 좌표 함수로
26// 계산하여 불변 바이트 경계를 지킨다.
28export record 준비된이미지요청 {
29 요청: 이미지요청,
30 구조: 준비된구조,
31 논리: Bytes
34export record 준비된이미지계획 {
35 요청: 준비된이미지요청,
36 계획: 이미지계획
39export record 이미지계획출력 {
40 쪽수: int,
41 세트해시: string,
42 높이들: Array<int>,
43 노드시작들: Array<int>,
44 노드수들: Array<int>,
45 논리길이들: Array<int>,
46 보호길이들: Array<int>,
47 패리티길이들: Array<int>
50function 요청검사(요청: 이미지요청) -> Result<준비된구조, string> {
51 if 요청.언어번호 != 1 && 요청.언어번호 != 2 && 요청.언어번호 != 3 &&
52 요청.언어번호 != 4 && 요청.언어번호 != 5 &&
53 요청.언어번호 != 6 && 요청.언어번호 != 7 &&
54 요청.언어번호 != 8 && 요청.언어번호 != 9 &&
55 요청.언어번호 != 10 && 요청.언어번호 != 11 &&
56 요청.언어번호 != 12 && 요청.언어번호 != 13 &&
57 요청.언어번호 != 14 && 요청.언어번호 != 15 &&
58 요청.언어번호 != 16 && 요청.언어번호 != 17 &&
59 요청.언어번호 != 18 && 요청.언어번호 != 19 &&
60 요청.언어번호 != 21 && 요청.언어번호 != 20 &&
61 요청.언어번호 != 22 && 요청.언어번호 != 23 &&
62 요청.언어번호 != 24 && 요청.언어번호 != 25 &&
63 요청.언어번호 != 26 && 요청.언어번호 != 27 &&
64 요청.언어번호 != 28 && 요청.언어번호 != 29 &&
65 요청.언어번호 != 30 {
66 return Err("지원하지 않는 언어입니다")
67 }
68 if 구조언어번호(요청.구조) != 요청.언어번호 { return Err("구조 뿌리의 언어가 이미지 요청과 다릅니다") }
69 인쇄구조검사(요청.언어번호, 요청.구조)?
70 if 요청.팔레트번호 != 요청.언어번호 || !이미지프로필해시맞음(요청.언어번호, 요청.프로필해시) {
71 return Err("언어 팔레트 프로필이 맞지 않습니다")
72 }
73 if 요청.프로필해시.scalars().length != 64 || 요청.구조해시.scalars().length != 64 || 요청.키해시.scalars().length != 64 {
74 return Err("이미지 해시 길이가 틀립니다")
75 }
76 if 요청.구조.분리본문키해시 != 요청.키해시 { return Err("구조와 키 해시가 다릅니다") }
77 if 요청.구조.노드들.length == 0 { return Err("이미지는 파일 뿌리 노드가 필요합니다") }
78 if 요청.크롬번호 < 0 || 요청.크롬번호 > 1 { return Err("크롬 번호가 틀립니다") }
79 if 요청.크롬번호 == 0 && (요청.제목 != "" || 요청.원본줄수 != 0) { return Err("민무늬 크롬에 책 메타데이터가 있습니다") }
80 let 제목바이트 = 요청.제목.encodeUtf8()
81 if 제목바이트.length() > 24 { return Err("책 제목이 24바이트를 넘습니다") }
82 for 글자 in 요청.제목.scalars() {
83 if 픽셀글꼴(글자) == "" { return Err("책 제목에 없는 픽셀 글자가 있습니다") }
84 }
85 Ok(준비된구조 { 언어번호: 요청.언어번호, 구조: 요청.구조 })
88function 이미지요청준비(요청글: string, 논리: Bytes) -> Result<준비된이미지요청, string> {
89 let 요청 = 이미지요청읽기(요청글)?
90 let 준비된구조값 = 요청검사(요청)?
91 if 논리.length() <= 0 { return Err("구조 논리 와이어가 비었습니다") }
92 Ok(준비된이미지요청 {
93 요청: 요청,
94 구조: 준비된구조값,
95 논리: 논리
96 })
99function 선호행경계(요청: 이미지요청) -> Array<int> {
100 let 노드들 = 요청.구조.노드들
101 let mut 경계들: Array<int> = []
102 let mut 순번 = 0
103 while 순번 < 노드들.length {
104 let 노드 = 노드들[순번]
105 if 범위코드(요청.언어번호, 노드.코드워드) && !파일프로그램코드(요청.언어번호, 노드.코드워드) {
106 let mut 끝 = 순번
107 let mut 살피기 = 순번 + 1
108 while 살피기 < 노드들.length && 조상또는자신(노드들, 살피기, 순번) { 끝 = 살피기; 살피기 = 살피기 + 1 }
109 if (끝 + 1) % 12 == 0 { 경계들.push((끝 + 1) / 12) }
110 }
111 순번 = 순번 + 1
112 }
113 경계들
116function 이미지세트해시계산(요청: 이미지요청, 논리: Bytes, 쪽들: Array<이미지쪽계획>) -> Result<string, string> {
117 let 크롬글 = if 요청.크롬번호 == 1 { "book" } else { "plain" }
118 let 논리해시바이트 = 해시이백오십육(논리)?
119 let 논리해시 = 논리해시바이트.toHex()
120 let 투영 = "\{" + json.stringify("chromePreset")? + ":" + json.stringify(크롬글)? +
121 "," + json.stringify("detachedTextKeySha256")? + ":" + json.stringify("sha256:" + 요청.키해시)? +
122 "," + json.stringify("domain")? + ":" + json.stringify("codeimage.js-total-format.v2.pageset")? +
123 "," + json.stringify("pages")? + ":" + 쪽투영문자열(쪽들)? +
124 "," + json.stringify("sourceLineCount")? + ":" + "{요청.원본줄수}" +
125 "," + json.stringify("structureDigest")? + ":" + json.stringify("sha256:" + 요청.구조해시)? +
126 "," + json.stringify("structureLogicalSha256")? + ":" + json.stringify("sha256:" + 논리해시)? +
127 "," + json.stringify("title")? + ":" + json.stringify(요청.제목)? + "\}"
128 let 세트해시바이트 = 해시이백오십육(투영.encodeUtf8())?
129 Ok(세트해시바이트.toHex())
132function 이미지계획준비(준비된요청: 준비된이미지요청) -> Result<준비된이미지계획, string> {
133 let 요청 = 준비된요청.요청
134 let 논리 = 준비된요청.논리
135 let 전체행수 = (요청.구조.노드들.length + 11) / 12
136 let 선호 = 선호행경계(요청)
137 let 꼬리 = if 요청.크롬번호 == 1 { 64 } else { 24 }
138 let mut 쪽수 = 1
139 while 쪽수 <= 32 {
140 let mut 논리시작들: Array<int> = []
141 let mut 논리끝들: Array<int> = []
142 let mut 보호길이들: Array<int> = []
143 let mut 용량들: Array<int> = []
144 let mut 유효 = true
145 let mut 쪽번호 = 0
146 while 쪽번호 < 쪽수 {
147 let 시작 = (논리.length() * 쪽번호) / 쪽수
148 let 끝 = (논리.length() * (쪽번호 + 1)) / 쪽수
149 if 끝 <= 시작 { 유효 = false }
150 let 길이 = 보호길이(끝 - 시작)
151 let 띠행수 = 큰값(1, (길이 + 161) / 162)
152 let 용량 = (2800 - (89 + 꼬리) - 띠행수 * 2) / 36
153 if 용량 < 1 { 유효 = false }
154 논리시작들.push(시작); 논리끝들.push(끝); 보호길이들.push(길이); 용량들.push(용량)
155 쪽번호 = 쪽번호 + 1
156 }
157 let mut 용량합 = 0
158 for 용량 in 용량들 { 용량합 = 용량합 + 용량 }
159 if 유효 && 용량합 >= 전체행수 {
160 let mut 행경계 = [0]
161 let mut 행시작 = 0
162 쪽번호 = 0
163 while 쪽번호 < 쪽수 - 1 {
164 let mut 남은용량 = 0
165 let mut 다음 = 쪽번호 + 1
166 while 다음 < 쪽수 { 남은용량 = 남은용량 + 용량들[다음]; 다음 = 다음 + 1 }
167 let 최소끝 = 큰값(행시작 + 1, 전체행수 - 남은용량)
168 let 최대끝 = 작은값(행시작 + 용량들[쪽번호], 전체행수 - (쪽수 - 쪽번호 - 1))
169 if 최소끝 > 최대끝 { 유효 = false }
170 let mut 행끝 = 최대끝
171 let mut 후보 = 최대끝
172 while 후보 >= 최소끝 {
173 if 배열에있음(선호, 후보) { 행끝 = 후보; 후보 = 최소끝 - 1 }
174 else { 후보 = 후보 - 1 }
175 }
176 행경계.push(행끝)
177 행시작 = 행끝
178 쪽번호 = 쪽번호 + 1
179 }
180 if 유효 {
181 행경계.push(전체행수)
182 let mut 쪽들: Array<이미지쪽계획> = []
183 쪽번호 = 0
184 while 쪽번호 < 쪽수 {
185 let 노드시작 = 행경계[쪽번호] * 12
186 let 노드끝 = 작은값(요청.구조.노드들.length, 행경계[쪽번호 + 1] * 12)
187 let 배치 = 이미지배치계산(노드끝 - 노드시작, 보호길이들[쪽번호], 요청.크롬번호)?
188 쪽들.push(이미지쪽계획 {
189 쪽번호: 쪽번호, 노드시작: 노드시작, 노드끝: 노드끝,
190 논리시작: 논리시작들[쪽번호], 논리끝: 논리끝들[쪽번호],
191 보호길이: 보호길이들[쪽번호], 패리티길이: (보호길이들[쪽번호] / 255) * 32,
192 배치: 배치
193 })
194 쪽번호 = 쪽번호 + 1
195 }
196 let 세트해시 = 이미지세트해시계산(요청, 논리, 쪽들)?
197 return Ok(준비된이미지계획 {
198 요청: 준비된요청,
199 계획: 이미지계획 { 쪽들: 쪽들, 세트해시: 세트해시 }
200 })
201 }
202 }
203 쪽수 = 쪽수 + 1
204 }
205 Err("이미지 세트가 32쪽 한계를 넘습니다")
208export function 이미지계획하기(요청글: string, 논리: Bytes) -> Result<string, string> {
209 let 준비된요청 = 이미지요청준비(요청글, 논리)?
210 let 준비된계획 = 이미지계획준비(준비된요청)?
211 let 계획 = 준비된계획.계획
212 let mut 높이들: Array<int> = []
213 let mut 노드시작들: Array<int> = []
214 let mut 노드수들: Array<int> = []
215 let mut 논리길이들: Array<int> = []
216 let mut 보호길이들: Array<int> = []
217 let mut 패리티길이들: Array<int> = []
218 for 쪽 in 계획.쪽들 {
219 높이들.push(쪽.배치.높이); 노드시작들.push(쪽.노드시작); 노드수들.push(쪽.노드끝 - 쪽.노드시작)
220 논리길이들.push(쪽.논리끝 - 쪽.논리시작); 보호길이들.push(쪽.보호길이); 패리티길이들.push(쪽.패리티길이)
221 }
222 json.stringify(이미지계획출력 {
223 쪽수: 계획.쪽들.length, 세트해시: 계획.세트해시, 높이들: 높이들,
224 노드시작들: 노드시작들, 노드수들: 노드수들, 논리길이들: 논리길이들,
225 보호길이들: 보호길이들, 패리티길이들: 패리티길이들
226 })
229function 이미지계획복원(
230 준비된요청: 준비된이미지요청,
231 출력: 이미지계획출력
232) -> Result<준비된이미지계획, string> {
233 let 요청 = 준비된요청.요청
234 let 논리 = 준비된요청.논리
235 let 쪽수 = 출력.쪽수
236 if 쪽수 <= 0 || 쪽수 > 32 { return Err("준비된 이미지 계획의 쪽 수가 범위를 벗어났습니다") }
237 if 출력.높이들.length != 쪽수 || 출력.노드시작들.length != 쪽수 ||
238 출력.노드수들.length != 쪽수 || 출력.논리길이들.length != 쪽수 ||
239 출력.보호길이들.length != 쪽수 || 출력.패리티길이들.length != 쪽수 {
240 return Err("준비된 이미지 계획의 배열 길이가 다릅니다")
241 }
242 let mut 쪽들: Array<이미지쪽계획> = []
243 let mut 다음노드 = 0
244 let mut 다음논리 = 0
245 let mut 쪽번호 = 0
246 while 쪽번호 < 쪽수 {
247 let 노드시작 = 출력.노드시작들[쪽번호]
248 let 노드수 = 출력.노드수들[쪽번호]
249 let 논리길이 = 출력.논리길이들[쪽번호]
250 let 보호 = 출력.보호길이들[쪽번호]
251 let 패리티 = 출력.패리티길이들[쪽번호]
252 if 노드시작 != 다음노드 || 노드수 <= 0 || 노드시작 + 노드수 > 요청.구조.노드들.length {
253 return Err("준비된 이미지 계획의 노드 범위가 올바르지 않습니다")
254 }
255 if 쪽번호 < 쪽수 - 1 && 노드수 % 12 != 0 {
256 return Err("준비된 이미지 계획의 노드 행 경계가 올바르지 않습니다")
257 }
258 if 논리길이 <= 0 || 다음논리 + 논리길이 > 논리.length() {
259 return Err("준비된 이미지 계획의 논리 범위가 올바르지 않습니다")
260 }
261 let 예상논리시작 = (논리.length() * 쪽번호) / 쪽수
262 let 예상논리끝 = (논리.length() * (쪽번호 + 1)) / 쪽수
263 if 다음논리 != 예상논리시작 || 다음논리 + 논리길이 != 예상논리끝 {
264 return Err("준비된 이미지 계획의 논리 분할이 올바르지 않습니다")
265 }
266 if 보호 != 보호길이(논리길이) || 패리티 != (보호 / 255) * 32 {
267 return Err("준비된 이미지 계획의 보호 길이가 올바르지 않습니다")
268 }
269 let 배치 = 이미지배치계산(노드수, 보호, 요청.크롬번호)?
270 if 배치.높이 != 출력.높이들[쪽번호] {
271 return Err("준비된 이미지 계획의 높이가 올바르지 않습니다")
272 }
273 쪽들.push(이미지쪽계획 {
274 쪽번호: 쪽번호, 노드시작: 노드시작, 노드끝: 노드시작 + 노드수,
275 논리시작: 다음논리, 논리끝: 다음논리 + 논리길이,
276 보호길이: 보호, 패리티길이: 패리티, 배치: 배치
277 })
278 다음노드 = 다음노드 + 노드수
279 다음논리 = 다음논리 + 논리길이
280 쪽번호 = 쪽번호 + 1
281 }
282 if 다음노드 != 요청.구조.노드들.length || 다음논리 != 논리.length() {
283 return Err("준비된 이미지 계획이 전체 입력을 덮지 않습니다")
284 }
285 let 세트해시 = 이미지세트해시계산(요청, 논리, 쪽들)?
286 if 세트해시 != 출력.세트해시 {
287 return Err("준비된 이미지 계획의 세트 해시가 다릅니다")
288 }
289 Ok(준비된이미지계획 {
290 요청: 준비된요청,
291 계획: 이미지계획 { 쪽들: 쪽들, 세트해시: 세트해시 }
292 })
295function 이미지쪽렌더계획됨(준비된계획: 준비된이미지계획, 쪽번호: int) -> Result<Bytes, string> {
296 let 요청 = 준비된계획.요청.요청
297 let 논리 = 준비된계획.요청.논리
298 let 계획 = 준비된계획.계획
299 if 쪽번호 < 0 || 쪽번호 >= 계획.쪽들.length { return Err("쪽 번호가 범위를 벗어났습니다") }
300 let 쪽 = 계획.쪽들[쪽번호]
301 let 논리조각 = 논리.slice(쪽.논리시작, 쪽.논리끝)
302 let 보호 = 리드솔로몬보호(논리조각)?
303 정규피엔지(그림준비하기(요청, 계획, 쪽, 보호)?)
306export function 이미지쪽렌더준비됨(요청글: string, 논리: Bytes, 계획글: string, 쪽번호: int) -> Result<Bytes, string> {
307 let 준비된요청 = 이미지요청준비(요청글, 논리)?
308 let 출력 = json.parseAs<이미지계획출력>(계획글)?
309 let 준비된계획 = 이미지계획복원(준비된요청, 출력)?
310 이미지쪽렌더계획됨(준비된계획, 쪽번호)
313export function 이미지쪽렌더(요청글: string, 논리: Bytes, 쪽번호: int) -> Result<Bytes, string> {
314 let 준비된요청 = 이미지요청준비(요청글, 논리)?
315 let 준비된계획 = 이미지계획준비(준비된요청)?
316 이미지쪽렌더계획됨(준비된계획, 쪽번호)
319function 이미지세트렌더계획됨(준비된계획: 준비된이미지계획) -> Result<Array<Bytes>, string> {
320 let mut 쪽들: Array<Bytes> = []
321 let mut 쪽번호 = 0
322 while 쪽번호 < 준비된계획.계획.쪽들.length {
323 쪽들.push(이미지쪽렌더계획됨(준비된계획, 쪽번호)?)
324 쪽번호 = 쪽번호 + 1
325 }
326 Ok(쪽들)
329export function 이미지세트렌더(요청글: string, 논리: Bytes) -> Result<Array<Bytes>, string> {
330 let 준비된요청 = 이미지요청준비(요청글, 논리)?
331 let 준비된계획 = 이미지계획준비(준비된요청)?
332 이미지세트렌더계획됨(준비된계획)
335export function 이미지세트계획렌더(요청글: string, 논리: Bytes) -> Result<Array<Bytes>, string> {
336 let 준비된요청 = 이미지요청준비(요청글, 논리)?
337 let 준비된계획 = 이미지계획준비(준비된요청)?
338 let mut 출력: Array<Bytes> = [Bytes.fromHex(준비된계획.계획.세트해시)?]
339 let 쪽들 = 이미지세트렌더계획됨(준비된계획)?
340 for 쪽 in 쪽들 { 출력.push(쪽) }
341 Ok(출력)

SHA256 d8770e1c3af0ac90de1b4b01b6554bd07b26b1e0442822d9bb4bd8a3a9ad7959