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.3
import std.bytes { Bytes }4
import std.json5
import ecc { 리드솔로몬보호 }6
import hash { 해시이백오십육 }7
import image_raster { 그림준비하기, 정규피엔지, 조상또는자신 }8
import plan {9
배열에있음,10
범위코드,11
보호길이,12
이미지계획,13
이미지배치,14
이미지배치계산,15
이미지쪽계획,16
이미지프로필해시맞음,17
쪽투영문자열,18
파일프로그램코드,19
픽셀글꼴,20
}21
import printers { 인쇄구조검사, 준비된구조 }22
import structure { 구조노드, 구조언어번호, 구조입력, 이미지요청, 이미지요청읽기 }23
import util { 작은값, 큰값 }25
// 이미지 운반체. 큰 래스터는 바이트 배열로 펼치지 않고 좌표 함수로26
// 계산하여 불변 바이트 경계를 지킨다.28
export record 준비된이미지요청 {29
요청: 이미지요청,30
구조: 준비된구조,31
논리: Bytes32
}34
export record 준비된이미지계획 {35
요청: 준비된이미지요청,36
계획: 이미지계획37
}39
export record 이미지계획출력 {40
쪽수: int,41
세트해시: string,42
높이들: Array<int>,43
노드시작들: Array<int>,44
노드수들: Array<int>,45
논리길이들: Array<int>,46
보호길이들: Array<int>,47
패리티길이들: Array<int>48
}50
function 요청검사(요청: 이미지요청) -> 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(준비된구조 { 언어번호: 요청.언어번호, 구조: 요청.구조 })86
}88
function 이미지요청준비(요청글: string, 논리: Bytes) -> Result<준비된이미지요청, string> {89
let 요청 = 이미지요청읽기(요청글)?90
let 준비된구조값 = 요청검사(요청)?91
if 논리.length() <= 0 { return Err("구조 논리 와이어가 비었습니다") }92
Ok(준비된이미지요청 {93
요청: 요청,94
구조: 준비된구조값,95
논리: 논리96
})97
}99
function 선호행경계(요청: 이미지요청) -> Array<int> {100
let 노드들 = 요청.구조.노드들101
let mut 경계들: Array<int> = []102
let mut 순번 = 0103
while 순번 < 노드들.length {104
let 노드 = 노드들[순번]105
if 범위코드(요청.언어번호, 노드.코드워드) && !파일프로그램코드(요청.언어번호, 노드.코드워드) {106
let mut 끝 = 순번107
let mut 살피기 = 순번 + 1108
while 살피기 < 노드들.length && 조상또는자신(노드들, 살피기, 순번) { 끝 = 살피기; 살피기 = 살피기 + 1 }109
if (끝 + 1) % 12 == 0 { 경계들.push((끝 + 1) / 12) }110
}111
순번 = 순번 + 1112
}113
경계들114
}116
function 이미지세트해시계산(요청: 이미지요청, 논리: 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())130
}132
function 이미지계획준비(준비된요청: 준비된이미지요청) -> Result<준비된이미지계획, string> {133
let 요청 = 준비된요청.요청134
let 논리 = 준비된요청.논리135
let 전체행수 = (요청.구조.노드들.length + 11) / 12136
let 선호 = 선호행경계(요청)137
let 꼬리 = if 요청.크롬번호 == 1 { 64 } else { 24 }138
let mut 쪽수 = 1139
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 유효 = true145
let mut 쪽번호 = 0146
while 쪽번호 < 쪽수 {147
let 시작 = (논리.length() * 쪽번호) / 쪽수148
let 끝 = (논리.length() * (쪽번호 + 1)) / 쪽수149
if 끝 <= 시작 { 유효 = false }150
let 길이 = 보호길이(끝 - 시작)151
let 띠행수 = 큰값(1, (길이 + 161) / 162)152
let 용량 = (2800 - (89 + 꼬리) - 띠행수 * 2) / 36153
if 용량 < 1 { 유효 = false }154
논리시작들.push(시작); 논리끝들.push(끝); 보호길이들.push(길이); 용량들.push(용량)155
쪽번호 = 쪽번호 + 1156
}157
let mut 용량합 = 0158
for 용량 in 용량들 { 용량합 = 용량합 + 용량 }159
if 유효 && 용량합 >= 전체행수 {160
let mut 행경계 = [0]161
let mut 행시작 = 0162
쪽번호 = 0163
while 쪽번호 < 쪽수 - 1 {164
let mut 남은용량 = 0165
let mut 다음 = 쪽번호 + 1166
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
쪽번호 = 쪽번호 + 1179
}180
if 유효 {181
행경계.push(전체행수)182
let mut 쪽들: Array<이미지쪽계획> = []183
쪽번호 = 0184
while 쪽번호 < 쪽수 {185
let 노드시작 = 행경계[쪽번호] * 12186
let 노드끝 = 작은값(요청.구조.노드들.length, 행경계[쪽번호 + 1] * 12)187
let 배치 = 이미지배치계산(노드끝 - 노드시작, 보호길이들[쪽번호], 요청.크롬번호)?188
쪽들.push(이미지쪽계획 {189
쪽번호: 쪽번호, 노드시작: 노드시작, 노드끝: 노드끝,190
논리시작: 논리시작들[쪽번호], 논리끝: 논리끝들[쪽번호],191
보호길이: 보호길이들[쪽번호], 패리티길이: (보호길이들[쪽번호] / 255) * 32,192
배치: 배치193
})194
쪽번호 = 쪽번호 + 1195
}196
let 세트해시 = 이미지세트해시계산(요청, 논리, 쪽들)?197
return Ok(준비된이미지계획 {198
요청: 준비된요청,199
계획: 이미지계획 { 쪽들: 쪽들, 세트해시: 세트해시 }200
})201
}202
}203
쪽수 = 쪽수 + 1204
}205
Err("이미지 세트가 32쪽 한계를 넘습니다")206
}208
export 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
})227
}229
function 이미지계획복원(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 다음노드 = 0244
let mut 다음논리 = 0245
let mut 쪽번호 = 0246
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
쪽번호 = 쪽번호 + 1281
}282
if 다음노드 != 요청.구조.노드들.length || 다음논리 != 논리.length() {283
return Err("준비된 이미지 계획이 전체 입력을 덮지 않습니다")284
}285
let 세트해시 = 이미지세트해시계산(요청, 논리, 쪽들)?286
if 세트해시 != 출력.세트해시 {287
return Err("준비된 이미지 계획의 세트 해시가 다릅니다")288
}289
Ok(준비된이미지계획 {290
요청: 준비된요청,291
계획: 이미지계획 { 쪽들: 쪽들, 세트해시: 세트해시 }292
})293
}295
function 이미지쪽렌더계획됨(준비된계획: 준비된이미지계획, 쪽번호: int) -> Result<Bytes, string> {296
let 요청 = 준비된계획.요청.요청297
let 논리 = 준비된계획.요청.논리298
let 계획 = 준비된계획.계획299
if 쪽번호 < 0 || 쪽번호 >= 계획.쪽들.length { return Err("쪽 번호가 범위를 벗어났습니다") }300
let 쪽 = 계획.쪽들[쪽번호]301
let 논리조각 = 논리.slice(쪽.논리시작, 쪽.논리끝)302
let 보호 = 리드솔로몬보호(논리조각)?303
정규피엔지(그림준비하기(요청, 계획, 쪽, 보호)?)304
}306
export function 이미지쪽렌더준비됨(요청글: string, 논리: Bytes, 계획글: string, 쪽번호: int) -> Result<Bytes, string> {307
let 준비된요청 = 이미지요청준비(요청글, 논리)?308
let 출력 = json.parseAs<이미지계획출력>(계획글)?309
let 준비된계획 = 이미지계획복원(준비된요청, 출력)?310
이미지쪽렌더계획됨(준비된계획, 쪽번호)311
}313
export function 이미지쪽렌더(요청글: string, 논리: Bytes, 쪽번호: int) -> Result<Bytes, string> {314
let 준비된요청 = 이미지요청준비(요청글, 논리)?315
let 준비된계획 = 이미지계획준비(준비된요청)?316
이미지쪽렌더계획됨(준비된계획, 쪽번호)317
}319
function 이미지세트렌더계획됨(준비된계획: 준비된이미지계획) -> Result<Array<Bytes>, string> {320
let mut 쪽들: Array<Bytes> = []321
let mut 쪽번호 = 0322
while 쪽번호 < 준비된계획.계획.쪽들.length {323
쪽들.push(이미지쪽렌더계획됨(준비된계획, 쪽번호)?)324
쪽번호 = 쪽번호 + 1325
}326
Ok(쪽들)327
}329
export function 이미지세트렌더(요청글: string, 논리: Bytes) -> Result<Array<Bytes>, string> {330
let 준비된요청 = 이미지요청준비(요청글, 논리)?331
let 준비된계획 = 이미지계획준비(준비된요청)?332
이미지세트렌더계획됨(준비된계획)333
}335
export 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(출력)342
}SHA256 d8770e1c3af0ac90de1b4b01b6554bd07b26b1e0442822d9bb4bd8a3a9ad7959