uint32_t * vtuDownsampleImageRGBA(const uint32_t *tex)
{
uint32_t *smallTex = (uint32_t *)malloc(c.pageDimension * c.pageDimension);
assert(smallTex);
for (uint16_t x = 0; x < c.pageDimension / 2; x++)
{
for (uint16_t y = 0; y < c.pageDimension / 2; y++)
{
#ifdef COLOR_CODE_MIPPED_PHYSTEX
smallTex[y * (c.pageDimension / 2) + x] = (255 << 24) + (0 << 16) + (0 << 8) + 255;
#else
uint32_t pix1 = tex[(y*2) * c.pageDimension + (x*2)];
uint32_t pix2 = tex[(y*2+1) * c.pageDimension + (x*2)];
uint32_t pix3 = tex[(y*2) * c.pageDimension + (x*2+1)];
uint32_t pix4 = tex[(y*2+1) * c.pageDimension + (x*2+1)];
uint32_t b1 = BYTE1(pix1) + BYTE1(pix2) + BYTE1(pix3) + BYTE1(pix4);
uint32_t b2 = BYTE2(pix1) + BYTE2(pix2) + BYTE2(pix3) + BYTE2(pix4);
uint32_t b3 = BYTE3(pix1) + BYTE3(pix2) + BYTE3(pix3) + BYTE3(pix4);
uint32_t b4 = BYTE4(pix1) + BYTE4(pix2) + BYTE4(pix3) + BYTE4(pix4);
smallTex[y * (c.pageDimension / 2) + x] = ((b4 / 4) << 24) + ((b3 / 4) << 16) + ((b2 / 4) << 8) + (b1 / 4); // ARGB
#endif
}
}
return smallTex;
}
static int put_multibyte(long c, FILE *fp) {
#ifdef WIN32
if (sjisterminal) {
const int fd = fileno(fp);
if ((fd == fileno(stdout) || fd == fileno(stderr)) && _isatty(fd)) {
HANDLE hStdout;
DWORD ret, wclen;
UINT cp;
wchar_t buff[2];
char str[4];
int mblen;
if (fd == fileno(stdout))
hStdout = GetStdHandle(STD_OUTPUT_HANDLE);
else
hStdout = GetStdHandle(STD_ERROR_HANDLE);
mblen=0;
if (BYTE1(c) != 0) str[mblen++]=BYTE1(c);
if (BYTE2(c) != 0) str[mblen++]=BYTE2(c);
if (BYTE3(c) != 0) str[mblen++]=BYTE3(c);
/* always */ str[mblen++]=BYTE4(c);
#define CP_932 932
#define CP_UTF8 65001
if (is_internalUPTEX())
cp = CP_UTF8;
else
cp = CP_932;
if (MultiByteToWideChar(cp, 0, str, mblen, buff, 2) == 0)
return EOF;
wclen = mblen > 3 ? 2 : 1;
if (WriteConsoleW(hStdout, buff, wclen, &ret, NULL) == 0)
return EOF;
return BYTE4(c);
}
}
#endif
if (BYTE1(c) != 0 && putc(BYTE1(c), fp) == EOF) return EOF;
if (BYTE2(c) != 0 && putc(BYTE2(c), fp) == EOF) return EOF;
if (BYTE3(c) != 0 && putc(BYTE3(c), fp) == EOF) return EOF;
/* always */ return putc(BYTE4(c), fp);
}
static void write_multibyte(long i)
{
if (BYTE1(i) != 0) buffer[last++] = BYTE1(i);
if (BYTE2(i) != 0) buffer[last++] = BYTE2(i);
/* always */ buffer[last++] = BYTE3(i);
/* always */ buffer[last++] = BYTE4(i);
}
static void scan_ScriptList(struct ft2vert_st *ret, const FT_Bytes top)
{
int i;
FT_Bytes s = top;
int ScriptCount;
ScriptCount = BYTE2(s);
for (i = 0; i < ScriptCount; i++)
{
FT_Tag ScriptTag = BYTE4(s);
FT_Bytes t = top + BYTE2(s);
if (ScriptTag == TAG_KANA)
scan_Script(ret, t, ScriptTag);
}
}
static void fprint_euc_char(FILE *fp, const char a, const char b)
{
if (is_internalUPTEX()) { /* convert a character from EUC to UTF8 */
int k = 0;
unsigned char str[5];
int chr = (unsigned char)a<<8 | (unsigned char)b;
chr = (chr==0xffff) ? U_REPLACEMENT_CHARACTER : JIStoUCS2(chr & 0x7f7f);
chr = UCStoUTF8(chr);
/* if (BYTE1(chr) != 0) str[k++] = BYTE1(chr); */ /* do not happen */
if (BYTE2(chr) != 0) str[k++] = BYTE2(chr);
if (BYTE3(chr) != 0) str[k++] = BYTE3(chr);
str[k++] = BYTE4(chr);
str[k++] = '\0';
fprintf(fp,"%s",str);
}
else
fprintf(fp,"%c%c",a,b);
}
static void scan_Script(struct ft2vert_st *ret, const FT_Bytes top, const FT_Tag ScriptTag)
{
int i;
FT_Bytes s = top;
FT_Offset DefaultLangSys;
int LangSysCount;
DefaultLangSys = BYTE2(s);
if (DefaultLangSys != 0)
scan_LangSys(ret, top + DefaultLangSys, ScriptTag);
LangSysCount = BYTE2(s);
for (i = 0; i < LangSysCount; i++)
{
FT_Tag LangSysTag = BYTE4(s);
FT_Bytes t = top + BYTE2(s);
if (LangSysTag == TAG_JAN)
scan_LangSys(ret, t, ScriptTag);
}
}
static void scan_FeatureList(struct ft2vert_st *ret, const FT_Bytes top)
{
int i;
FT_Bytes s = top;
int FeatureCount;
FeatureCount = BYTE2(s);
for (i = 0; i < FeatureCount; i++)
{
FT_Tag FeatureTag = BYTE4(s);
FT_Offset Feature = BYTE2(s);
if (isInIndex(ret->kanaFeature, i))
{
switch (FeatureTag)
{
case TAG_VERT: ret->vertLookup = top + Feature + 2; break;
case TAG_VRT2: ret->vrt2Lookup = top + Feature + 2; break;
}
}
}
}
static void scan_GSUB_Header(fz_context *ctx, struct ft2vert_st *ret, const FT_Bytes top)
{
FT_Bytes s = top;
FT_Fixed Version;
FT_Offset ScriptList;
FT_Offset FeatureList;
FT_Offset LookupList;
Version = BYTE4(s);
ScriptList = BYTE2(s);
FeatureList = BYTE2(s);
LookupList = BYTE2(s);
if (Version != 0x00010000)
fz_warn(ctx, "GSUB Version (=%.1f) is not 1.0\n", (double)Version / 0x10000);
scan_ScriptList(ret, top + ScriptList);
scan_FeatureList(ret, top + FeatureList);
/* vrt2 has higher priority over vert */
if (ret->vrt2Lookup != NULL)
ret->vertLookup = ret->vrt2Lookup;
scan_LookupList(ctx, ret, top + LookupList);
}
/* putc() with code conversion */
int putc2(int c, FILE *fp)
{
static int num[NOFILE];
/* 0 : not in Kanji
1..4 : in JIS Kanji and num[] bytes are in store[][]
-1 : in JIS Kanji and store[][] is empty */
static unsigned char store[NOFILE][4];
const int fd = fileno(fp);
int ret = c, output_enc;
#ifdef WIN32
if ((fp == stdout || fp == stderr) && (_isatty(fd) || !prior_file_enc)) {
if (sjisterminal) {
if (is_internalUPTEX())
output_enc = ENC_UTF8;
else
output_enc = ENC_SJIS;
} else
#else
if ((fp == stdout || fp == stderr) && !prior_file_enc) {
#endif
output_enc = get_terminal_enc();
} else
output_enc = get_file_enc();
if (num[fd] > 0) { /* multi-byte char */
if (is_internalUPTEX() && iskanji1(c)) { /* error */
ret = flush(store[fd], num[fd], fp);
num[fd] = 0;
}
store[fd][num[fd]] = c;
num[fd]++;
if (multistrlen(store[fd], num[fd], 0) == num[fd]) {
long i = fromBUFF(store[fd], num[fd], 0);
ret = put_multibyte(toENC(i, output_enc), fp);
num[fd] = -1;
} else if ((is_internalUPTEX() && num[fd] == 4) ||
(!is_internalUPTEX() && num[fd] == 2)) { /* error */
ret = flush(store[fd], num[fd], fp);
num[fd] = -1;
}
} else if (iskanji1(c)) { /* first multi-byte char */
if (num[fd] == 0 && output_enc == ENC_JIS) {
ret = put_multibyte(KANJI_IN, fp);
}
store[fd][0] = c;
num[fd] = 1;
} else { /* ASCII */
if (num[fd] < 0 && output_enc == ENC_JIS) {
put_multibyte(KANJI_OUT, fp);
}
ret = putc(c, fp);
num[fd] = 0;
}
return ret;
}
/* fputs() with code conversion */
int fputs2(const char *s, FILE *fp)
{
while (*s != '\0') {
int ret = putc2((unsigned char)*s, fp);
if (ret == EOF) return EOF;
s++;
}
return 1;
}
static struct unget_st {
int size;
int buff[4];
} ungetbuff[NOFILE];
static int getc4(FILE *fp)
{
struct unget_st *p = &ungetbuff[fileno(fp)];
if (p->size == 0)
#ifdef WIN32
{
const int fd = fileno(fp);
HANDLE hStdin;
DWORD ret;
wchar_t wc[2];
long c;
static wchar_t wcbuf = L'\0';
if (!(fd == fileno(stdin) && _isatty(fd) && is_internalUPTEX()))
return getc(fp);
hStdin = GetStdHandle(STD_INPUT_HANDLE);
if (wcbuf) {
wc[0] = wcbuf;
wcbuf = L'\0';
}
else if (ReadConsoleW(hStdin, wc, 1, &ret, NULL) == 0)
return EOF;
if (0xd800<=wc[0] && wc[0]<0xdc00) {
if (ReadConsoleW(hStdin, wc+1, 1, &ret, NULL) == 0)
return EOF;
if (0xdc00<=wc[1] && wc[1]<0xe000) {
c = UTF16StoUTF32(wc[0], wc[1]);
} else {
wcbuf = wc[1];
c = U_REPLACEMENT_CHARACTER; /* illegal upper surrogate pair */
}
} else if (0xdc00<=wc[0] && wc[0]<0xe000) {
c = U_REPLACEMENT_CHARACTER; /* illegal lower surrogate pair */
} else {
c = wc[0];
}
c = UCStoUTF8(c);
/* always */ p->buff[p->size++]=BYTE4(c);
if (BYTE3(c) != 0) p->buff[p->size++]=BYTE3(c);
if (BYTE2(c) != 0) p->buff[p->size++]=BYTE2(c);
if (BYTE1(c) != 0) p->buff[p->size++]=BYTE1(c);
}
#else
return getc(fp);
#endif
return p->buff[--p->size];
}
static int ungetc4(int c, FILE *fp)
{
struct unget_st *p = &ungetbuff[fileno(fp)];
if (p->size >= 4) return EOF;
return p->buff[p->size++] = c;
}
static unsigned char *buffer;
static long first, last;
static boolean combin_voiced_sound(boolean semi)
{
int i, mblen;
mblen = is_internalUPTEX() ? 3 : 2;
if (last-mblen < first) return false;
if (multistrlen(buffer,last,last-mblen) != mblen) return false;
i = toUCS(fromBUFF(buffer,last,last-mblen));
i = get_voiced_sound(i, semi);
if (i == 0) return false;
i = toBUFF(fromUCS(i));
if (BYTE2(i) != 0) buffer[last-3] = BYTE2(i);
/* always */ buffer[last-2] = BYTE3(i);
/* always */ buffer[last-1] = BYTE4(i);
return true;
}
static FT_Error
TA_font_build_TTC_header(FONT* font,
FT_Byte** header_buf,
FT_ULong* header_len)
{
SFNT* sfnts = font->sfnts;
FT_Long num_sfnts = font->num_sfnts;
SFNT_Table* tables = font->tables;
FT_ULong num_tables = font->num_tables;
FT_ULong TTF_offset;
FT_ULong DSIG_offset;
FT_Byte* buf;
FT_ULong len;
FT_Long i;
FT_Byte* p;
len = (font->have_DSIG ? 24 : 12) + 4 * num_sfnts;
buf = (FT_Byte*)malloc(len);
if (!buf)
return FT_Err_Out_Of_Memory;
p = buf;
/* TTC ID string */
*(p++) = 't';
*(p++) = 't';
*(p++) = 'c';
*(p++) = 'f';
/* TTC header version */
*(p++) = 0x00;
*(p++) = font->have_DSIG ? 0x02 : 0x01;
*(p++) = 0x00;
*(p++) = 0x00;
/* number of subfonts */
*(p++) = BYTE1(num_sfnts);
*(p++) = BYTE2(num_sfnts);
*(p++) = BYTE3(num_sfnts);
*(p++) = BYTE4(num_sfnts);
/* the first TTF subfont header immediately follows the TTC header */
TTF_offset = len;
/* loop over all subfonts */
for (i = 0; i < num_sfnts; i++)
{
SFNT* sfnt = &sfnts[i];
FT_ULong l;
TA_sfnt_sort_table_info(sfnt, font);
/* only get header length */
(void)TA_sfnt_build_TTF_header(sfnt, font, NULL, &l, 0);
*(p++) = BYTE1(TTF_offset);
*(p++) = BYTE2(TTF_offset);
*(p++) = BYTE3(TTF_offset);
*(p++) = BYTE4(TTF_offset);
TTF_offset += l;
}
/* the first SFNT table immediately follows the subfont TTF headers */
TA_font_compute_table_offsets(font, TTF_offset);
if (font->have_DSIG)
{
/* DSIG tag */
*(p++) = 'D';
*(p++) = 'S';
*(p++) = 'I';
*(p++) = 'G';
/* DSIG length */
*(p++) = 0x00;
*(p++) = 0x00;
*(p++) = 0x00;
*(p++) = 0x08;
/* DSIG offset; in a TTC this is always the last SFNT table */
DSIG_offset = tables[num_tables - 1].offset;
*(p++) = BYTE1(DSIG_offset);
*(p++) = BYTE2(DSIG_offset);
*(p++) = BYTE3(DSIG_offset);
*(p++) = BYTE4(DSIG_offset);
}
*header_buf = buf;
*header_len = len;
return TA_Err_Ok;
}
FT_Error
TA_sfnt_build_TTF_header(SFNT* sfnt,
FONT* font,
FT_Byte** header_buf,
FT_ULong* header_len,
FT_Int do_complete)
{
SFNT_Table* tables = font->tables;
SFNT_Table_Info* table_infos = sfnt->table_infos;
FT_ULong num_table_infos = sfnt->num_table_infos;
FT_Byte* buf;
FT_ULong len;
FT_Byte* table_record;
FT_Byte* head_buf = NULL; /* pointer to `head' table */
FT_ULong head_checksum; /* checksum in `head' table */
FT_ULong num_tables_in_header;
FT_ULong i;
num_tables_in_header = 0;
for (i = 0; i < num_table_infos; i++)
{
/* ignore empty tables */
if (table_infos[i] != MISSING)
num_tables_in_header++;
}
len = 12 + 16 * num_tables_in_header;
if (!do_complete)
{
*header_len = len;
return TA_Err_Ok;
}
buf = (FT_Byte*)malloc(len);
if (!buf)
return FT_Err_Out_Of_Memory;
/* SFNT version */
buf[0] = 0x00;
buf[1] = 0x01;
buf[2] = 0x00;
buf[3] = 0x00;
/* number of tables */
buf[4] = HIGH(num_tables_in_header);
buf[5] = LOW(num_tables_in_header);
/* auxiliary data */
{
FT_ULong search_range, entry_selector, range_shift;
FT_ULong i, j;
for (i = 1, j = 2; j <= num_tables_in_header; i++, j <<= 1)
;
entry_selector = i - 1;
search_range = 0x10 << entry_selector;
range_shift = (num_tables_in_header << 4) - search_range;
buf[6] = HIGH(search_range);
buf[7] = LOW(search_range);
buf[8] = HIGH(entry_selector);
buf[9] = LOW(entry_selector);
buf[10] = HIGH(range_shift);
buf[11] = LOW(range_shift);
}
/* location of the first table info record */
table_record = &buf[12];
head_checksum = 0;
/* loop over all tables */
for (i = 0; i < num_table_infos; i++)
{
SFNT_Table_Info table_info = table_infos[i];
SFNT_Table* table;
/* ignore empty slots */
if (table_info == MISSING)
continue;
table = &tables[table_info];
if (table->tag == TTAG_head)
{
FT_ULong date_high;
FT_ULong date_low;
/* we always reach this IF clause since FreeType would */
/* have aborted already if the `head' table were missing */
head_buf = table->buf;
/* reset checksum in `head' table for recalculation */
head_buf[8] = 0x00;
head_buf[9] = 0x00;
head_buf[10] = 0x00;
head_buf[11] = 0x00;
/* update modification time */
TA_get_current_time(&date_high, &date_low);
head_buf[28] = BYTE1(date_high);
head_buf[29] = BYTE2(date_high);
head_buf[30] = BYTE3(date_high);
head_buf[31] = BYTE4(date_high);
head_buf[32] = BYTE1(date_low);
head_buf[33] = BYTE2(date_low);
head_buf[34] = BYTE3(date_low);
head_buf[35] = BYTE4(date_low);
table->checksum = TA_table_compute_checksum(table->buf, table->len);
}
head_checksum += table->checksum;
table_record[0] = BYTE1(table->tag);
table_record[1] = BYTE2(table->tag);
table_record[2] = BYTE3(table->tag);
table_record[3] = BYTE4(table->tag);
table_record[4] = BYTE1(table->checksum);
table_record[5] = BYTE2(table->checksum);
table_record[6] = BYTE3(table->checksum);
table_record[7] = BYTE4(table->checksum);
table_record[8] = BYTE1(table->offset);
table_record[9] = BYTE2(table->offset);
table_record[10] = BYTE3(table->offset);
table_record[11] = BYTE4(table->offset);
table_record[12] = BYTE1(table->len);
table_record[13] = BYTE2(table->len);
table_record[14] = BYTE3(table->len);
table_record[15] = BYTE4(table->len);
table_record += 16;
}
/* the font header is complete; compute `head' checksum */
head_checksum += TA_table_compute_checksum(buf, len);
head_checksum = 0xB1B0AFBAUL - head_checksum;
/* store checksum in `head' table; */
head_buf[8] = BYTE1(head_checksum);
head_buf[9] = BYTE2(head_checksum);
head_buf[10] = BYTE3(head_checksum);
head_buf[11] = BYTE4(head_checksum);
*header_buf = buf;
*header_len = len;
return TA_Err_Ok;
}
static int checkSCSICommand(void* MSDStatus, usb_device_t* device, uint16_t TransferLength, uint8_t SCSIOpcode)
{
// CSW Status
#ifdef _USB_DIAGNOSIS_
putch('\n');
memshow(MSDStatus,13, false);
putch('\n');
#endif
int error = 0;
// check signature 0x53425355 // DWORD 0 (byte 0:3)
uint32_t CSWsignature = *(uint32_t*)MSDStatus; // DWORD 0
if (CSWsignature == CSWMagicOK)
{
#ifdef _USB_DIAGNOSIS_
textColor(SUCCESS);
printf("\nCSW signature OK ");
textColor(TEXT);
#endif
}
else if (CSWsignature == CSWMagicNotOK)
{
textColor(ERROR);
printf("\nCSW signature wrong (not processed)");
textColor(TEXT);
return -1;
}
else
{
textColor(ERROR);
printf("\nCSW signature wrong (processed, but wrong value)");
textColor(TEXT);
error = -2;
}
// check matching tag
uint32_t CSWtag = *(((uint32_t*)MSDStatus)+1); // DWORD 1 (byte 4:7)
if ((BYTE1(CSWtag) == SCSIOpcode) && (BYTE2(CSWtag) == 0x42) && (BYTE3(CSWtag) == 0x42) && (BYTE4(CSWtag) == 0x42))
{
#ifdef _USB_DIAGNOSIS_
textColor(SUCCESS);
printf("CSW tag %yh OK ",BYTE1(CSWtag));
textColor(TEXT);
#endif
}
else
{
textColor(ERROR);
printf("\nError: CSW tag wrong");
textColor(TEXT);
error = -3;
}
// check CSWDataResidue
uint32_t CSWDataResidue = *(((uint32_t*)MSDStatus)+2); // DWORD 2 (byte 8:11)
if (CSWDataResidue == 0)
{
#ifdef _USB_DIAGNOSIS_
textColor(SUCCESS);
printf("\tCSW data residue OK ");
textColor(TEXT);
#endif
}
else
{
textColor(0x06);
printf("\nCSW data residue: %u", CSWDataResidue);
textColor(TEXT);
}
// check status byte // DWORD 3 (byte 12)
uint8_t CSWstatusByte = *(((uint8_t*)MSDStatus)+12); // byte 12 (last byte of 13 bytes)
textColor(ERROR);
switch (CSWstatusByte)
{
case 0x00:
#ifdef _USB_DIAGNOSIS_
textColor(SUCCESS);
printf("\tCSW status OK");
#endif
break;
case 0x01:
printf("\nCommand failed");
error = -4;
break;
case 0x02:
printf("\nPhase Error");
textColor(IMPORTANT);
printf("\nReset recovery is needed");
usb_resetRecoveryMSD(device, device->numInterfaceMSD);
error = -5;
break;
default:
printf("\nCSW status byte: undefined value (error)");
error = -6;
break;
}
textColor(TEXT);
return error;
}
static void formatSCSICommand(uint8_t SCSIcommand, struct usb_CommandBlockWrapper* cbw, uint32_t LBA, uint16_t TransferLength)
{
memset(cbw, 0, sizeof(struct usb_CommandBlockWrapper));
switch (SCSIcommand)
{
case 0x00: // test unit ready(6)
cbw->CBWSignature = CBWMagic; // magic
cbw->CBWTag = 0x42424200; // device echoes this field in the CSWTag field of the associated CSW
cbw->CBWFlags = 0x00; // Out: 0x00 In: 0x80
cbw->CBWCBLength = 6; // only bits 4:0
break;
case 0x03: // Request Sense(6)
cbw->CBWSignature = CBWMagic; // magic
cbw->CBWTag = 0x42424203; // device echoes this field in the CSWTag field of the associated CSW
cbw->CBWDataTransferLength = 18;
cbw->CBWFlags = 0x80; // Out: 0x00 In: 0x80
cbw->CBWCBLength = 6; // only bits 4:0
cbw->commandByte[0] = 0x03; // Operation code
cbw->commandByte[4] = 18; // Allocation length (max. bytes)
break;
case 0x12: // Inquiry(6)
cbw->CBWSignature = CBWMagic; // magic
cbw->CBWTag = 0x42424212; // device echoes this field in the CSWTag field of the associated CSW
cbw->CBWDataTransferLength = 36;
cbw->CBWFlags = 0x80; // Out: 0x00 In: 0x80
cbw->CBWCBLength = 6; // only bits 4:0
cbw->commandByte[0] = 0x12; // Operation code
cbw->commandByte[4] = 36; // Allocation length (max. bytes)
break;
case 0x25: // read capacity(10)
cbw->CBWSignature = CBWMagic; // magic
cbw->CBWTag = 0x42424225; // device echoes this field in the CSWTag field of the associated CSW
cbw->CBWDataTransferLength = 8;
cbw->CBWFlags = 0x80; // Out: 0x00 In: 0x80
cbw->CBWCBLength = 10; // only bits 4:0
cbw->commandByte[0] = 0x25; // Operation code
cbw->commandByte[2] = BYTE4(LBA); // LBA MSB
cbw->commandByte[3] = BYTE3(LBA); // LBA
cbw->commandByte[4] = BYTE2(LBA); // LBA
cbw->commandByte[5] = BYTE1(LBA); // LBA LSB
break;
case 0x28: // read(10)
cbw->CBWSignature = CBWMagic; // magic
cbw->CBWTag = 0x42424228; // device echoes this field in the CSWTag field of the associated CSW
cbw->CBWDataTransferLength = TransferLength*512; // byte = 512 * block
cbw->CBWFlags = 0x80; // Out: 0x00 In: 0x80
cbw->CBWCBLength = 10; // only bits 4:0
cbw->commandByte[0] = 0x28; // Operation code
cbw->commandByte[2] = BYTE4(LBA); // LBA MSB
cbw->commandByte[3] = BYTE3(LBA); // LBA
cbw->commandByte[4] = BYTE2(LBA); // LBA
cbw->commandByte[5] = BYTE1(LBA); // LBA LSB
cbw->commandByte[7] = BYTE2(TransferLength); // MSB <--- blocks not byte!
cbw->commandByte[8] = BYTE1(TransferLength); // LSB
break;
case 0x2A: // write(10)
cbw->CBWSignature = CBWMagic; // magic
cbw->CBWTag = 0x4242422A; // device echoes this field in the CSWTag field of the associated CSW
cbw->CBWDataTransferLength = TransferLength*512; // byte = 512 * block
cbw->CBWFlags = 0x00; // Out: 0x00 In: 0x80
cbw->CBWCBLength = 10; // only bits 4:0
cbw->commandByte[0] = 0x2A; // Operation code
cbw->commandByte[2] = BYTE4(LBA); // LBA MSB
cbw->commandByte[3] = BYTE3(LBA); // LBA
cbw->commandByte[4] = BYTE2(LBA); // LBA
cbw->commandByte[5] = BYTE1(LBA); // LBA LSB
cbw->commandByte[7] = BYTE2(TransferLength); // MSB <--- blocks not byte!
cbw->commandByte[8] = BYTE1(TransferLength); // LSB
break;
}
}
