自学教程：C++ uint8_t函数代码示例

void ServerLink::Send(Game::Property::Stream properties) {	Packet::Packet packet      { Packet::Type::kProperties, uint8_t(server_slot_), properties.Packed() };  data_.Push(packet.Packed());}

Entry* probe(const Position& pos) {  Key key = pos.material_key();  Entry* e = pos.this_thread()->materialTable[key];  if (e->key == key)      return e;  std::memset(e, 0, sizeof(Entry));  e->key = key;  e->factor[WHITE] = e->factor[BLACK] = (uint8_t)SCALE_FACTOR_NORMAL;  e->gamePhase = pos.game_phase();  // Let's look if we have a specialized evaluation function for this particular  // material configuration. Firstly we look for a fixed configuration one, then  // for a generic one if the previous search failed.  if ((e->evaluationFunction = pos.this_thread()->endgames.probe<Value>(key)) != nullptr)      return e;  for (Color c = WHITE; c <= BLACK; ++c)      if (is_KXK(pos, c))      {          e->evaluationFunction = &EvaluateKXK[c];          return e;      }  // OK, we didn't find any special evaluation function for the current material  // configuration. Is there a suitable specialized scaling function?  EndgameBase<ScaleFactor>* sf;  if ((sf = pos.this_thread()->endgames.probe<ScaleFactor>(key)) != nullptr)  {      e->scalingFunction[sf->strong_side()] = sf; // Only strong color assigned      return e;  }  // We didn't find any specialized scaling function, so fall back on generic  // ones that refer to more than one material distribution. Note that in this  // case we don't return after setting the function.  for (Color c = WHITE; c <= BLACK; ++c)  {    if (is_KBPsKs(pos, c))        e->scalingFunction[c] = &ScaleKBPsK[c];    else if (is_KQKRPs(pos, c))        e->scalingFunction[c] = &ScaleKQKRPs[c];  }  Value npm_w = pos.non_pawn_material(WHITE);  Value npm_b = pos.non_pawn_material(BLACK);  if (npm_w + npm_b == VALUE_ZERO && pos.pieces(PAWN)) // Only pawns on the board  {      if (!pos.count<PAWN>(BLACK))      {          assert(pos.count<PAWN>(WHITE) >= 2);          e->scalingFunction[WHITE] = &ScaleKPsK[WHITE];      }      else if (!pos.count<PAWN>(WHITE))      {          assert(pos.count<PAWN>(BLACK) >= 2);          e->scalingFunction[BLACK] = &ScaleKPsK[BLACK];      }      else if (pos.count<PAWN>(WHITE) == 1 && pos.count<PAWN>(BLACK) == 1)      {          // This is a special case because we set scaling functions          // for both colors instead of only one.          e->scalingFunction[WHITE] = &ScaleKPKP[WHITE];          e->scalingFunction[BLACK] = &ScaleKPKP[BLACK];      }  }  // Zero or just one pawn makes it difficult to win, even with a small material  // advantage. This catches some trivial draws like KK, KBK and KNK and gives a  // drawish scale factor for cases such as KRKBP and KmmKm (except for KBBKN).  if (!pos.count<PAWN>(WHITE) && npm_w - npm_b <= BishopValueMg)      e->factor[WHITE] = uint8_t(npm_w <  RookValueMg   ? SCALE_FACTOR_DRAW :                                 npm_b <= BishopValueMg ? 4 : 14);  if (!pos.count<PAWN>(BLACK) && npm_b - npm_w <= BishopValueMg)      e->factor[BLACK] = uint8_t(npm_b <  RookValueMg   ? SCALE_FACTOR_DRAW :                                 npm_w <= BishopValueMg ? 4 : 14);  if (pos.count<PAWN>(WHITE) == 1 && npm_w - npm_b <= BishopValueMg)      e->factor[WHITE] = (uint8_t) SCALE_FACTOR_ONEPAWN;  if (pos.count<PAWN>(BLACK) == 1 && npm_b - npm_w <= BishopValueMg)      e->factor[BLACK] = (uint8_t) SCALE_FACTOR_ONEPAWN;  // Evaluate the material imbalance. We use PIECE_TYPE_NONE as a place holder  // for the bishop pair "extended piece", which allows us to be more flexible  // in defining bishop pair bonuses.  const int PieceCount[COLOR_NB][PIECE_TYPE_NB] = {  { pos.count<BISHOP>(WHITE) > 1, pos.count<PAWN>(WHITE), pos.count<KNIGHT>(WHITE),    pos.count<BISHOP>(WHITE)    , pos.count<ROOK>(WHITE), pos.count<QUEEN >(WHITE) },  { pos.count<BISHOP>(BLACK) > 1, pos.count<PAWN>(BLACK), pos.count<KNIGHT>(BLACK),    pos.count<BISHOP>(BLACK)    , pos.count<ROOK>(BLACK), pos.count<QUEEN >(BLACK) } };//.........这里部分代码省略.........

 void DevicePool_c::calcChecksumAdd( const char* str ) {   const size_t l = CNAMESPACE::strlen( str );   calcChecksumAdd( uint8_t( l ) );   calcChecksumAdd( ( const uint8_t* )str, l ); }

std::string term_clear() {    std::ostringstream oss;    oss << uint8_t(0x1b) << "[2J";    return oss.str();}

Entry* probe(const Position& pos, Table& entries, Endgames& endgames) {  Key key = pos.material_key();  Entry* e = entries[key];  // If e->key matches the position's material hash key, it means that we  // have analysed this material configuration before, and we can simply  // return the information we found the last time instead of recomputing it.  if (e->key == key)      return e;  std::memset(e, 0, sizeof(Entry));  e->key = key;  e->factor[WHITE] = e->factor[BLACK] = (uint8_t)SCALE_FACTOR_NORMAL;  e->gamePhase = game_phase(pos);  // Let's look if we have a specialized evaluation function for this particular  // material configuration. Firstly we look for a fixed configuration one, then  // for a generic one if the previous search failed.  if (endgames.probe(key, e->evaluationFunction))      return e;  if (is_KXK<WHITE>(pos))  {      e->evaluationFunction = &EvaluateKXK[WHITE];      return e;  }  if (is_KXK<BLACK>(pos))  {      e->evaluationFunction = &EvaluateKXK[BLACK];      return e;  }  // OK, we didn't find any special evaluation function for the current  // material configuration. Is there a suitable scaling function?  //  // We face problems when there are several conflicting applicable  // scaling functions and we need to decide which one to use.  EndgameBase<ScaleFactor>* sf;  if (endgames.probe(key, sf))  {      e->scalingFunction[sf->color()] = sf;      return e;  }  // Generic scaling functions that refer to more than one material  // distribution. They should be probed after the specialized ones.  // Note that these ones don't return after setting the function.  if (is_KBPsKs<WHITE>(pos))      e->scalingFunction[WHITE] = &ScaleKBPsK[WHITE];  if (is_KBPsKs<BLACK>(pos))      e->scalingFunction[BLACK] = &ScaleKBPsK[BLACK];  if (is_KQKRPs<WHITE>(pos))      e->scalingFunction[WHITE] = &ScaleKQKRPs[WHITE];  else if (is_KQKRPs<BLACK>(pos))      e->scalingFunction[BLACK] = &ScaleKQKRPs[BLACK];  Value npm_w = pos.non_pawn_material(WHITE);  Value npm_b = pos.non_pawn_material(BLACK);  if (npm_w + npm_b == VALUE_ZERO && pos.pieces(PAWN))  {      if (!pos.count<PAWN>(BLACK))      {          assert(pos.count<PAWN>(WHITE) >= 2);          e->scalingFunction[WHITE] = &ScaleKPsK[WHITE];      }      else if (!pos.count<PAWN>(WHITE))      {          assert(pos.count<PAWN>(BLACK) >= 2);          e->scalingFunction[BLACK] = &ScaleKPsK[BLACK];      }      else if (pos.count<PAWN>(WHITE) == 1 && pos.count<PAWN>(BLACK) == 1)      {          // This is a special case because we set scaling functions          // for both colors instead of only one.          e->scalingFunction[WHITE] = &ScaleKPKP[WHITE];          e->scalingFunction[BLACK] = &ScaleKPKP[BLACK];      }  }  // No pawns makes it difficult to win, even with a material advantage. This  // catches some trivial draws like KK, KBK and KNK and gives a very drawish  // scale factor for cases such as KRKBP and KmmKm (except for KBBKN).  if (!pos.count<PAWN>(WHITE) && npm_w - npm_b <= BishopValueMg)      e->factor[WHITE] = uint8_t(npm_w < RookValueMg ? SCALE_FACTOR_DRAW : npm_b <= BishopValueMg ? 4 : 12);  if (!pos.count<PAWN>(BLACK) && npm_b - npm_w <= BishopValueMg)      e->factor[BLACK] = uint8_t(npm_b < RookValueMg ? SCALE_FACTOR_DRAW : npm_w <= BishopValueMg ? 4 : 12);  if (pos.count<PAWN>(WHITE) == 1 && npm_w - npm_b <= BishopValueMg)      e->factor[WHITE] = (uint8_t) SCALE_FACTOR_ONEPAWN;  if (pos.count<PAWN>(BLACK) == 1 && npm_b - npm_w <= BishopValueMg)      e->factor[BLACK] = (uint8_t) SCALE_FACTOR_ONEPAWN;//.........这里部分代码省略.........

void RageSurfaceUtils::ErrorDiffusionDither( const RageSurface *src, RageSurface *dst ){	// We can't dither to paletted surfaces.	ASSERT( dst->format->BytesPerPixel > 1 );	uint32_t src_cbits[4], dst_cbits[4];	RageSurfaceUtils::GetBitsPerChannel( src->format, src_cbits );	RageSurfaceUtils::GetBitsPerChannel( dst->format, dst_cbits );	// Calculate the ratio from the old bit depth to the new for each color channel.	int conv[4];	for( int i = 0; i < 4; ++i )	{		int MaxInputIntensity = (1 << src_cbits[i])-1;		int MaxOutputIntensity = (1 << dst_cbits[i])-1;		// If the source is missing the channel, avoid div/0.		if( MaxInputIntensity == 0 )			conv[i] = 0;		else			conv[i] = MaxOutputIntensity * 65536 / MaxInputIntensity;	}	// Max alpha value; used when there's no alpha source.	const uint8_t alpha_max = uint8_t((1 << dst_cbits[3]) - 1);	// For each row:	for(int row = 0; row < src->h; ++row) 	{		int32_t accumError[4] = { 0, 0, 0, 0 }; // accum error values are reset every row		const uint8_t *srcp = src->pixels + row * src->pitch;		uint8_t *dstp = dst->pixels + row * dst->pitch;		// For each pixel in row:		for( int col = 0; col < src->w; ++col )		{			uint8_t colors[4];			RageSurfaceUtils::GetRawRGBAV( srcp, src->fmt, colors );			for( int c = 0; c < 3; ++c )			{				colors[c] = EDDitherPixel( col, row, colors[c], conv[c], accumError[c] );			}			/* If the source has no alpha, the conversion formula will end up			 * with 0; that's fine for color channels, but for alpha we need to			 * be opaque. */			if( src_cbits[3] == 0 )			{				colors[3] = alpha_max;			} else {				/* Same as DitherPixel, except it doesn't actually dither;				 * dithering looks bad on the alpha channel. */				int out_intensity = colors[3] * conv[3];				// Round:				colors[3] = uint8_t((out_intensity + 32767) >> 16);			}			RageSurfaceUtils::SetRawRGBAV( dstp, dst, colors );			srcp += src->format->BytesPerPixel;			dstp += dst->format->BytesPerPixel;		}	}}

/** *  Write to the I2C device. * *  Returns: An error code. */uint8_t Max6651ClosedLoop::write(Register command, uint8_t data) const {  return i2c_->write(address_, uint8_t(command), data);}

void DS2433::duty(OneWireHub * const hub){    constexpr uint8_t ALTERNATE_01 { 0b10101010 };    static uint16_t reg_TA { 0 }; // contains TA1, TA2 (Target Address)    static uint8_t  reg_ES { 31 };  // E/S register    uint8_t  data, cmd;    uint16_t crc { 0 };    if (hub->recv(&cmd,1,crc))  return;    switch (cmd)    {        case 0x0F:      // WRITE SCRATCHPAD COMMAND            if (hub->recv(reinterpret_cast<uint8_t *>(&reg_TA),2,crc)) return;            reg_TA &= MEM_MASK; // make sure to stay in boundary            reg_ES = uint8_t(reg_TA) & PAGE_MASK; // register-offset            // receive up to 8 bytes of data            for (; reg_ES < PAGE_SIZE; ++reg_ES)            {                if (hub->recv(&scratchpad[reg_ES], 1, crc))                {                    if (hub->getError() == Error::AWAIT_TIMESLOT_TIMEOUT_HIGH) reg_ES |= REG_ES_PF_MASK;                    break;                }            }            reg_ES--;            reg_ES &= PAGE_MASK;            if (hub->getError() == Error::NO_ERROR)  // try to send crc if wanted            {                crc = ~crc; // normally crc16 is sent ~inverted                hub->send(reinterpret_cast<uint8_t *>(&crc), 2);            }            break;        case 0x55:      // COPY SCRATCHPAD            if (hub->recv(&data)) return; // TA1            if (data != reinterpret_cast<uint8_t *>(&reg_TA)[0]) return;            if (hub->recv(&data)) return;  // TA2            if (data != reinterpret_cast<uint8_t *>(&reg_TA)[1]) return;            if (hub->recv(&data)) return;  // ES            if (data != reg_ES) return;            if ((reg_ES & REG_ES_PF_MASK) != 0)                  break; // stop if error occured earlier            reg_ES |= REG_ES_AA_MASK; // compare was successful            {    // Write Scratchpad to memory, writing takes about 5ms                const uint8_t start  = uint8_t(reg_TA) & PAGE_MASK;                const uint8_t length = (reg_ES & PAGE_MASK)+ uint8_t(1) - start;                writeMemory(&scratchpad[start], length, reg_TA);            }            noInterrupts();            do            {                hub->clearError();                hub->sendBit(true); // send passive 1s            }            while   (hub->getError() == Error::AWAIT_TIMESLOT_TIMEOUT_HIGH); // wait for timeslots            interrupts();            while (!hub->send(&ALTERNATE_01)); // send alternating 1 & 0 after copy is complete            break;        case 0xAA:      // READ SCRATCHPAD COMMAND            if (hub->send(reinterpret_cast<uint8_t *>(&reg_TA),2))  return;            if (hub->send(&reg_ES,1)) return;            {   // send Scratchpad content                const uint8_t start  = uint8_t(reg_TA) & PAGE_MASK;                const uint8_t length = PAGE_SIZE - start;                if (hub->send(&scratchpad[start],length))   return;            }            return; // datasheed says we should send all 1s, till reset (1s are passive... so nothing to do here)        case 0xF0:      // READ MEMORY            if (hub->recv(reinterpret_cast<uint8_t *>(&reg_TA),2)) return;            for (uint16_t i = reg_TA; i < MEM_SIZE; i+=PAGE_SIZE) // model of the 32byte scratchpad            {                if (hub->send(&memory[i],PAGE_SIZE)) return;            }            return; // datasheed says we should send all 1s, till reset (1s are passive... so nothing to do here)        default:            hub->raiseSlaveError(cmd);    }}

 inline void pack( Stream& s, const variant& v ) {    pack( s, uint8_t(v.get_type()) );    v.visit( variant_packer<Stream>(s) ); }

static voidIncrementMutationCount(uint8_t* aCount){    *aCount = uint8_t(std::min(0xFF, *aCount + 1));}

////// @brief Configure the ARR0 of the CCS instruction for mrs05, data object as input/// @param[in] i_target a fapi2::Target<fapi2::TARGET_TYPE_DIMM>/// @param[in] i_data an mrs05_data object, filled in/// @param[in,out] io_inst the instruction to fixup/// @param[in] i_rank the rank in question/// @return FAPI2_RC_SUCCESS iff OK///fapi2::ReturnCode mrs05(const fapi2::Target<fapi2::TARGET_TYPE_DIMM>& i_target,                        const mrs05_data& i_data,                        ccs::instruction_t<fapi2::TARGET_TYPE_MCBIST>& io_inst,                        const uint64_t i_rank){    constexpr uint64_t CA_PARITY_LATENCY_LENGTH = 3;    constexpr uint64_t CA_PARITY_LATENCY_START = 7;    constexpr uint64_t RTT_PARK_LENGTH = 3;    constexpr uint64_t RTT_PARK_START = 7;    constexpr uint64_t CA_PARITY_COUNT = 9;    //                                                             0                4      5      6         8    constexpr uint8_t ca_parity_latency_map[CA_PARITY_COUNT] = { 0b000, 0, 0, 0, 0b001, 0b010, 0b011, 0, 0b100 };    fapi2::buffer<uint8_t> l_ca_parity_latency_buffer;    fapi2::buffer<uint8_t> l_rtt_park_buffer = i_data.iv_rtt_park[mss::index(i_rank)];    //check here to make sure the rank indexes correctly into the attribute array    FAPI_ASSERT( (mss::index(i_rank) < MAX_RANK_PER_DIMM),                 fapi2::MSS_BAD_MR_PARAMETER()                 .set_MR_NUMBER(5)                 .set_PARAMETER(RANK)                 .set_PARAMETER_VALUE(i_rank)                 .set_DIMM_IN_ERROR(i_target),                 "Bad value for RTT park: %d (%s)", i_rank, mss::c_str(i_target));    FAPI_ASSERT( (i_data.iv_ca_parity_latency < CA_PARITY_COUNT),                 fapi2::MSS_BAD_MR_PARAMETER()                 .set_MR_NUMBER(5)                 .set_PARAMETER(CA_PARITY_LATENCY)                 .set_PARAMETER_VALUE(i_data.iv_ca_parity_latency)                 .set_DIMM_IN_ERROR(i_target),                 "Bad value for CA parity latency: %d (%s)", i_data.iv_ca_parity_latency, mss::c_str(i_target));    l_ca_parity_latency_buffer = ca_parity_latency_map[i_data.iv_ca_parity_latency];    FAPI_INF("%s MR5 rank %d attributes: CAPL: 0x%x(0x%x), CRC_EC: 0x%x, CA_PES: 0x%x, ODT_IB: 0x%x "             "RTT_PARK: 0x%x, CAP: 0x%x, DM: 0x%x, WDBI: 0x%x, RDBI: 0x%x",             mss::c_str(i_target), i_rank, i_data.iv_ca_parity_latency, uint8_t(l_ca_parity_latency_buffer),             i_data.iv_crc_error_clear, i_data.iv_ca_parity_error_status, i_data.iv_odt_input_buffer,             uint8_t(l_rtt_park_buffer), i_data.iv_ca_parity,             i_data.iv_data_mask, i_data.iv_write_dbi, i_data.iv_read_dbi);    mss::swizzle<A0, CA_PARITY_LATENCY_LENGTH, CA_PARITY_LATENCY_START>(l_ca_parity_latency_buffer, io_inst.arr0);    io_inst.arr0.writeBit<A3>(i_data.iv_crc_error_clear);    io_inst.arr0.writeBit<A4>(i_data.iv_ca_parity_error_status);    io_inst.arr0.writeBit<A5>(i_data.iv_odt_input_buffer);    mss::swizzle<A6, RTT_PARK_LENGTH, RTT_PARK_START>(l_rtt_park_buffer, io_inst.arr0);    io_inst.arr0.writeBit<A9>(i_data.iv_ca_parity);    io_inst.arr0.writeBit<A10>(i_data.iv_data_mask);    io_inst.arr0.writeBit<A11>(i_data.iv_write_dbi);    io_inst.arr0.writeBit<A12>(i_data.iv_read_dbi);    FAPI_INF("%s MR5: 0x%016llx", mss::c_str(i_target), uint64_t(io_inst.arr0));    return fapi2::FAPI2_RC_SUCCESS;fapi_try_exit:    return fapi2::current_err;}

ArgType immType(const Op opcode, int idx) {  assert(isValidOpcode(opcode));  assert(idx >= 0 && idx < numImmediates(opcode));  always_assert(idx < 4); // No opcodes have more than four immediates  static const int8_t arg0Types[] = {#define NA -1,#define ONE(a) a,#define TWO(a, b) a,#define THREE(a, b, c) a,#define FOUR(a, b, c, d) a,#define O(name, imm, unusedPop, unusedPush, unusedFlags) imm    OPCODES// re-using definition of O below.#undef NA#undef ONE#undef TWO#undef THREE#undef FOUR  };  static const int8_t arg1Types[] = {#define NA -1,#define ONE(a) -1,#define TWO(a, b) b,#define THREE(a, b, c) b,#define FOUR(a, b, c, d) b,    OPCODES// re-using definition of O below.#undef NA#undef ONE#undef TWO#undef THREE#undef FOUR  };  static const int8_t arg2Types[] = {#define NA -1,#define ONE(a) -1,#define TWO(a, b) -1,#define THREE(a, b, c) c,#define FOUR(a, b, c, d) c,    OPCODES#undef NA#undef ONE#undef TWO#undef THREE#undef FOUR  };  static const int8_t arg3Types[] = {#define NA -1,#define ONE(a) -1,#define TWO(a, b) -1,#define THREE(a, b, c) -1,#define FOUR(a, b, c, d) d,    OPCODES#undef O#undef NA#undef ONE#undef TWO#undef THREE#undef FOUR  };  auto opInt = uint8_t(opcode);  switch (idx) {    case 0: return (ArgType)arg0Types[opInt];    case 1: return (ArgType)arg1Types[opInt];    case 2: return (ArgType)arg2Types[opInt];    case 3: return (ArgType)arg3Types[opInt];    default: assert(false); return (ArgType)-1;  }}

Offset* instrJumpOffset(Op* instr) {  static const int8_t jumpMask[] = {#define NA 0#define MA 0#define IVA 0#define I64A 0#define DA 0#define SA 0#define AA 0#define BA 1#define LA 0#define IA 0#define OA 0#define ONE(a) a#define TWO(a, b) (a + 2 * b)#define THREE(a, b, c) (a + 2 * b + 4 * c)#define FOUR(a, b, c, d) (a + 2 * b + 4 * c + 8 * d)#define O(name, imm, pop, push, flags) imm,    OPCODES#undef NA#undef MA#undef IVA#undef I64A#undef DA#undef SA#undef AA#undef LA#undef IA#undef BA#undef OA#undef ONE#undef TWO#undef THREE#undef FOUR#undef O  };  assert(!isSwitch(*instr));  if (Op(*instr) == OpIterBreak) {    uint32_t veclen = *(uint32_t *)(instr + 1);    assert(veclen > 0);    Offset* target  = (Offset *)((uint32_t *)(instr + 1) + 2 * veclen + 1);    return target;  }  int mask = jumpMask[uint8_t(*instr)];  if (mask == 0) {    return nullptr;  }  int immNum;  switch (mask) {    case 0: return nullptr;    case 1: immNum = 0; break;    case 2: immNum = 1; break;    case 4: immNum = 2; break;    case 8: immNum = 3; break;    default: assert(false); return nullptr;  }  return &getImmPtr(instr, immNum)->u_BA;}

static int generate_joint_tables(HYuvContext *s){    uint16_t symbols[1 << VLC_BITS];    uint16_t bits[1 << VLC_BITS];    uint8_t len[1 << VLC_BITS];    int ret;    if (s->bitstream_bpp < 24) {        int p, i, y, u;        for (p = 0; p < 3; p++) {            for (i = y = 0; y < 256; y++) {                int len0 = s->len[0][y];                int limit = VLC_BITS - len0;                if(limit <= 0 || !len0)                    continue;                for (u = 0; u < 256; u++) {                    int len1 = s->len[p][u];                    if (len1 > limit || !len1)                        continue;                    av_assert0(i < (1 << VLC_BITS));                    len[i] = len0 + len1;                    bits[i] = (s->bits[0][y] << len1) + s->bits[p][u];                    symbols[i] = (y << 8) + u;                    if(symbols[i] != 0xffff) // reserved to mean "invalid"                        i++;                }            }            ff_free_vlc(&s->vlc[3 + p]);            if ((ret = ff_init_vlc_sparse(&s->vlc[3 + p], VLC_BITS, i, len, 1, 1,                                          bits, 2, 2, symbols, 2, 2, 0)) < 0)                return ret;        }    } else {        uint8_t (*map)[4] = (uint8_t(*)[4])s->pix_bgr_map;        int i, b, g, r, code;        int p0 = s->decorrelate;        int p1 = !s->decorrelate;        // restrict the range to +/-16 because that's pretty much guaranteed to        // cover all the combinations that fit in 11 bits total, and it doesn't        // matter if we miss a few rare codes.        for (i = 0, g = -16; g < 16; g++) {            int len0 = s->len[p0][g & 255];            int limit0 = VLC_BITS - len0;            if (limit0 < 2 || !len0)                continue;            for (b = -16; b < 16; b++) {                int len1 = s->len[p1][b & 255];                int limit1 = limit0 - len1;                if (limit1 < 1 || !len1)                    continue;                code = (s->bits[p0][g & 255] << len1) + s->bits[p1][b & 255];                for (r = -16; r < 16; r++) {                    int len2 = s->len[2][r & 255];                    if (len2 > limit1 || !len2)                        continue;                    av_assert0(i < (1 << VLC_BITS));                    len[i] = len0 + len1 + len2;                    bits[i] = (code << len2) + s->bits[2][r & 255];                    if (s->decorrelate) {                        map[i][G] = g;                        map[i][B] = g + b;                        map[i][R] = g + r;                    } else {                        map[i][B] = g;                        map[i][G] = b;                        map[i][R] = r;                    }                    i++;                }            }        }        ff_free_vlc(&s->vlc[3]);        if ((ret = init_vlc(&s->vlc[3], VLC_BITS, i, len, 1, 1, bits, 2, 2, 0)) < 0)            return ret;    }    return 0;}

surfel_mem_array reduction_spatially_subdivided_random::create_lod(real& reduction_error,          const std::vector<surfel_mem_array*>& input,          const uint32_t surfels_per_node,          const bvh& tree,          const size_t start_node_id) const{    surfel_mem_array mem_array(std::make_shared<surfel_vector>(surfel_vector()), 0, 0);    std::vector<surfel> already_picked_surfel;    std::vector<surfel> original_surfels;    auto const& tree_nodes = tree.nodes();    auto combined_bounding_box = tree_nodes[start_node_id].get_bounding_box();    for( uint8_t non_first_child_ids = 1;          non_first_child_ids < tree.fan_factor();          ++non_first_child_ids) {        auto const& sibling_bb = tree_nodes[start_node_id + non_first_child_ids].get_bounding_box();        combined_bounding_box.expand( sibling_bb.max() );        combined_bounding_box.expand( sibling_bb.min() );    }    uint32_t const num_divisions_for_shortest_axis = 8;    vec3r step_length(-1.0, -1.0, -1.0);    uint8_t shortest_axis = -1;    real min_length = std::numeric_limits<real>::max();    vec3r axis_lengths = combined_bounding_box.max() - combined_bounding_box.min();    for( uint8_t axis_idx = 0; axis_idx < 3; ++axis_idx ) {        if( axis_lengths[axis_idx] < min_length ) {            min_length = axis_lengths[axis_idx];            shortest_axis = axis_idx;        }    }    step_length[shortest_axis] = axis_lengths[shortest_axis] / num_divisions_for_shortest_axis;    vec3b steps_per_axis(-1,-1,-1);    steps_per_axis[shortest_axis] = num_divisions_for_shortest_axis;    for( uint8_t axis_idx = 0; axis_idx < 3; ++axis_idx ) {        if (axis_idx != shortest_axis) {            uint32_t num_axis_steps = std::max(1, int(std::ceil(  axis_lengths[axis_idx] / step_length[shortest_axis] ) ) );            step_length[axis_idx] = axis_lengths[axis_idx] / num_axis_steps;            steps_per_axis[axis_idx] = num_axis_steps;        }    }    std::vector< std::vector<surfel> > spatially_divided_surfels;        spatially_divided_surfels.resize( steps_per_axis[0]*steps_per_axis[1]*steps_per_axis[2] );    for (size_t node_id = 0; node_id < input.size(); ++node_id) {        for (size_t surfel_id = input[node_id]->offset();                    surfel_id < input[node_id]->offset() + input[node_id]->length();                    ++surfel_id){                        //this surfel will be referenced in the entropy surfel            auto current_surfel = input[node_id]->mem_data()->at(input[node_id]->offset() + surfel_id);                        // ignore outlier radii of any kind            if (current_surfel.radius() == 0.0) {                continue;            }             uint32_t x_summand = std::max(uint8_t(0), std::min( uint8_t( steps_per_axis[0] - 1), uint8_t( ( current_surfel.pos()[0] - combined_bounding_box.min()[0] ) /                                 ( combined_bounding_box.max()[0] - combined_bounding_box.min()[0] ) *                                 steps_per_axis[0]) ) ) * steps_per_axis[1] * steps_per_axis[2];            uint32_t y_summand = std::max(uint8_t(0), std::min( uint8_t(steps_per_axis[1] - 1), uint8_t( ( current_surfel.pos()[1] - combined_bounding_box.min()[1] ) /                                 ( combined_bounding_box.max()[1] - combined_bounding_box.min()[1] ) *                                 steps_per_axis[1]) ) ) * steps_per_axis[2];            uint32_t z_summand = std::max(uint8_t(0), std::min( uint8_t(steps_per_axis[2] - 1), uint8_t( ( current_surfel.pos()[2] - combined_bounding_box.min()[2] ) /                                 ( combined_bounding_box.max()[2] - combined_bounding_box.min()[2] ) *                                 steps_per_axis[2]) ) );            uint32_t box_id = x_summand + y_summand + z_summand;            spatially_divided_surfels[box_id].push_back(current_surfel);            original_surfels.push_back(current_surfel);       }    }    std::sort(std::begin(spatially_divided_surfels), std::end(spatially_divided_surfels), [](std::vector<surfel> const& lhs, std::vector<surfel> const& rhs) { return lhs.size() > rhs.size();});        while( spatially_divided_surfels.back().empty() ){//.........这里部分代码省略.........

}void RageSurfaceUtils::encodepixel( uint8_t *p, int bpp, uint32_t pixel ){	switch(bpp)	{	case 1: *p = uint8_t(pixel); break;	case 2: *(uint16_t *)p = uint16_t(pixel); break;	case 3:		if( BYTE_ORDER == BIG_ENDIAN )		{			p[0] = uint8_t((pixel >> 16) & 0xff);			p[1] = uint8_t((pixel >> 8) & 0xff);			p[2] = uint8_t(pixel & 0xff);		} else {			p[0] = uint8_t(pixel & 0xff);			p[1] = uint8_t((pixel >> 8) & 0xff);			p[2] = uint8_t((pixel >> 16) & 0xff);		}		break;	case 4: *(uint32_t *)p = pixel; break;	}}// Get and set colors without scaling to 0..255.void RageSurfaceUtils::GetRawRGBAV( uint32_t pixel, const RageSurfaceFormat &fmt, uint8_t *v ){	if( fmt.BytesPerPixel == 1 )	{		v[0] = fmt.palette->colors[pixel].r;		v[1] = fmt.palette->colors[pixel].g;

 void TED7360::initRegisters() {   cycle_count = 0;   videoColumn = 100;   // initialize memory paging   memoryReadMap = 0x06F8U;   memoryWriteMap = 0x0678U;   cpuMemoryReadMap = 0x06F8U;   tedDMAReadMap = 0x07F8U;   tedBitmapReadMap = 0x07F8U;   // clear memory used by TED registers   ioRegister_0000 = uint8_t(0x0F);   ioRegister_0001 = uint8_t(0xC8);   if (tedRegisters[0x07] & uint8_t(0x40)) {     tedRegisters[0x07] = uint8_t(0x00);     ntscModeChangeCallback(false);   }   for (uint8_t i = 0x00; i <= 0x1F; i++)     tedRegisters[i] = tedRegisterInit[i];   // set internal TED registers   render_func = &render_char_std;   current_render_func = &render_border;   videoLine = 224;   characterLine = 0;   characterPosition = 0x0000;   savedCharacterPosition = 0x0000;   characterPositionReload = 0x0000;   characterColumn = 0;   dmaPosition = 0x03FF;   dmaPositionReload = 0x03FF;   dmaBaseAddr = 0x0000;   bitmap_base_addr = 0x0000;   charset_base_addr = 0x0000;   cursor_position = 0x03FF;   ted_disabled = false;   flashState = 0x00;   renderWindow = false;   incrementingCharacterLine = false;   bitmapAddressDisableFlags = 0x03;   displayWindow = false;   displayActive = false;   videoOutputFlags = 0x30;   vsyncFlags = 0x00;   timer1_run = true;                          // timers   timer2_run = true;   timer3_run = true;   timer1_state = 0;   timer1_reload_value = 0;   timer2_state = 0;   timer3_state = 0;   soundChannel1Cnt = 0x03FF;                  // sound generators   soundChannel1Reload = 0x03FF;   soundChannel2Cnt = 0x03FF;   soundChannel2Reload = 0x03FF;   prvSoundChannel1Overflow = false;   prvSoundChannel2Overflow = false;   soundChannel1Decay = 131072U;   soundChannel2Decay = 131072U;   soundChannel1State = uint8_t(1);   soundChannel2State = uint8_t(1);   soundChannel2NoiseState = uint8_t(0xFF);   soundChannel2NoiseOutput = uint8_t(1);   soundVolume = 0x00;   soundChannel1Output = 0x00;   soundChannel2Output = 0x00;   prvSoundOutput = 0x00;   for (int i = 0; i < 64; i++) {              // video buffers     attr_buf[i] = uint8_t(0);     attr_buf_tmp[i] = uint8_t(0);     char_buf[i] = uint8_t(0);   }   for (int i = 0; i < 464; i++)     video_buf[i] = uint8_t(0x00);   prv_video_buf_pos = 0;   video_buf_pos = 0;   videoShiftRegisterEnabled = false;   videoMode = 0x00;   characterMask = uint8_t(0x7F);   for (int i = 0; i < 5; i++)     colorRegisters[i] = uint8_t(0x80);   horizontalScroll = 0;   verticalScroll = 3;   dmaEnabled = false;   savedVideoLineDelay1 = 223;   singleClockModeFlags = 0x00;   externalFetchSingleClockFlag = true;   dmaFlags = 0x00;   dmaActive = false;   incrementingDMAPosition = false;   incrementingCharacterPosition = false;   cpuHaltedFlag = false;   delayedEvents0 = 0U;   delayedEvents1 = 0U;   savedVideoLine = 224;   videoInterruptLine = 0;   prvVideoInterruptState = false;   prvCharacterLine = 0;   dataBusState = uint8_t(0xFF);   dramRefreshAddrL = 0x00;   keyboard_row_select_mask = 0xFFFF;//.........这里部分代码省略.........

 TED7360::TED7360() : M7501() {   tedRegisters[0x07] = uint8_t(0x00);         // default to PAL mode   for (int i = 0; i < int(sizeof(callbacks) / sizeof(TEDCallback)); i++) {     callbacks[i].func = (void (*)(void *)) 0;     callbacks[i].userData = (void *) 0;     callbacks[i].nxt0 = (TEDCallback *) 0;     callbacks[i].nxt1 = (TEDCallback *) 0;   }   firstCallback0 = (TEDCallback *) 0;   firstCallback1 = (TEDCallback *) 0;   // create initial memory map   ramSegments = 0;   ramPatternCode = 0UL;   randomSeed = Plus4Emu::Timer::getRandomSeedFromTime() & 0x7FFFFFFFU;   for (int i = 0; i < 256; i++)     segmentTable[i] = (uint8_t *) 0;   try {     setRAMSize(64);   }   catch (...) {     for (int i = 0; i < 256; i++) {       if (segmentTable[i] != (uint8_t *) 0) {         delete[] segmentTable[i];         segmentTable[i] = (uint8_t *) 0;       }     }     throw;   }   setMemoryCallbackUserData(this);   for (uint16_t i = 0x0000; i <= 0x0FFF; i++) {     setMemoryReadCallback(i, &read_memory_0000_to_0FFF);     setMemoryWriteCallback(i, &write_memory_0000_to_0FFF);   }   for (uint16_t i = 0x1000; i <= 0x3FFF; i++) {     setMemoryReadCallback(i, &read_memory_1000_to_3FFF);     setMemoryWriteCallback(i, &write_memory_1000_to_3FFF);   }   for (uint16_t i = 0x4000; i <= 0x7FFF; i++) {     setMemoryReadCallback(i, &read_memory_4000_to_7FFF);     setMemoryWriteCallback(i, &write_memory_4000_to_7FFF);   }   for (uint16_t i = 0x8000; i <= 0xBFFF; i++) {     setMemoryReadCallback(i, &read_memory_8000_to_BFFF);     setMemoryWriteCallback(i, &write_memory_8000_to_BFFF);   }   for (uint16_t i = 0xC000; i <= 0xFBFF; i++) {     setMemoryReadCallback(i, &read_memory_C000_to_FBFF);     setMemoryWriteCallback(i, &write_memory_C000_to_FBFF);   }   for (uint16_t i = 0xFC00; i <= 0xFCFF; i++) {     setMemoryReadCallback(i, &read_memory_FC00_to_FCFF);     setMemoryWriteCallback(i, &write_memory_FC00_to_FCFF);   }   for (uint16_t i = 0xFD00; i <= 0xFEFF; i++) {     setMemoryReadCallback(i, &read_memory_FD00_to_FEFF);     setMemoryWriteCallback(i, &write_memory_FD00_to_FEFF);   }   for (uint16_t i = 0xFF00; i <= 0xFF1F; i++) {     setMemoryReadCallback(i, &read_register_FFxx);     setMemoryWriteCallback(i, &write_register_FFxx);   }   for (uint32_t i = 0xFF20; i <= 0xFFFF; i++) {     setMemoryReadCallback(uint16_t(i), &read_memory_FF00_to_FFFF);     setMemoryWriteCallback(uint16_t(i), &write_memory_FF00_to_FFFF);   }   // TED register read   setMemoryReadCallback(0x0000, &read_register_0000);   setMemoryReadCallback(0x0001, &read_register_0001);   for (uint16_t i = 0xFD00; i <= 0xFD0F; i++)     setMemoryReadCallback(i, &read_register_FD0x);   for (uint16_t i = 0xFD10; i <= 0xFD1F; i++)     setMemoryReadCallback(i, &read_register_FD1x);   setMemoryReadCallback(0xFD16, &read_register_FD16);   for (uint16_t i = 0xFD30; i <= 0xFD3F; i++)     setMemoryReadCallback(i, &read_register_FD3x);   setMemoryReadCallback(0xFF00, &read_register_FF00);   setMemoryReadCallback(0xFF01, &read_register_FF01);   setMemoryReadCallback(0xFF02, &read_register_FF02);   setMemoryReadCallback(0xFF03, &read_register_FF03);   setMemoryReadCallback(0xFF04, &read_register_FF04);   setMemoryReadCallback(0xFF05, &read_register_FF05);   setMemoryReadCallback(0xFF06, &read_register_FF06);   setMemoryReadCallback(0xFF09, &read_register_FF09);   setMemoryReadCallback(0xFF0A, &read_register_FF0A);   setMemoryReadCallback(0xFF0C, &read_register_FF0C);   setMemoryReadCallback(0xFF10, &read_register_FF10);   setMemoryReadCallback(0xFF12, &read_register_FF12);   setMemoryReadCallback(0xFF13, &read_register_FF13);   setMemoryReadCallback(0xFF14, &read_register_FF14);   setMemoryReadCallback(0xFF1A, &read_register_FF1A);   setMemoryReadCallback(0xFF1B, &read_register_FF1B);   setMemoryReadCallback(0xFF1C, &read_register_FF1C);   setMemoryReadCallback(0xFF1E, &read_register_FF1E);   setMemoryReadCallback(0xFF1F, &read_register_FF1F);   setMemoryReadCallback(0xFF3E, &read_register_FF3E_FF3F);   setMemoryReadCallback(0xFF3F, &read_register_FF3E_FF3F);   // TED register write   setMemoryWriteCallback(0x0000, &write_register_0000);   setMemoryWriteCallback(0x0001, &write_register_0001);//.........这里部分代码省略.........

void PtexMainWriter::writeMetaData(FILE* fp){    std::vector<MetaEntry*> lmdEntries; // large meta data items    // write small meta data items in a single zip block    for (int i = 0, n = _metadata.size(); i < n; i++) {	MetaEntry& e = _metadata[i];#ifndef PTEX_NO_LARGE_METADATA_BLOCKS	if (int(e.data.size()) > MetaDataThreshold) {	    // skip large items, but record for later	    lmdEntries.push_back(&e);	}	else #endif    {	    // add small item to zip block	    _header.metadatamemsize += writeMetaDataBlock(fp, e);	}    }    if (_header.metadatamemsize) {	// finish zip block	_header.metadatazipsize = writeZipBlock(fp, 0, 0, /*finish*/ true);    }    // write compatibility barrier    writeBlank(fp, sizeof(uint64_t));    // write large items as separate blocks    int nLmd = lmdEntries.size();    if (nLmd > 0) {	// write data records to tmp file and accumulate zip sizes for lmd header	std::vector<FilePos> lmdoffset(nLmd);	std::vector<uint32_t> lmdzipsize(nLmd);	for (int i = 0; i < nLmd; i++) {	    MetaEntry* e= lmdEntries[i];	    lmdoffset[i] = ftello(_tmpfp);	    lmdzipsize[i] = writeZipBlock(_tmpfp, &e->data[0], e->data.size());	}	// write lmd header records as single zip block	for (int i = 0; i < nLmd; i++) {	    MetaEntry* e = lmdEntries[i];	    uint8_t keysize = uint8_t(e->key.size()+1);	    uint8_t datatype = e->datatype;	    uint32_t datasize = e->data.size();	    uint32_t zipsize = lmdzipsize[i];	    writeZipBlock(fp, &keysize, sizeof(keysize), false);	    writeZipBlock(fp, e->key.c_str(), keysize, false);	    writeZipBlock(fp, &datatype, sizeof(datatype), false);	    writeZipBlock(fp, &datasize, sizeof(datasize), false);	    writeZipBlock(fp, &zipsize, sizeof(zipsize), false);	    _extheader.lmdheadermemsize +=		sizeof(keysize) + keysize + sizeof(datatype) + sizeof(datasize) + sizeof(zipsize);	}	_extheader.lmdheaderzipsize = writeZipBlock(fp, 0, 0, /*finish*/ true);	// copy data records	for (int i = 0; i < nLmd; i++) {	    _extheader.lmddatasize +=		copyBlock(fp, _tmpfp, lmdoffset[i], lmdzipsize[i]);	}    }}

void SequenceParser::sendPlaybookInformation(const std::string& name) {    std::string fullName = std::string(PlaybookIdentifierName) + "_" + name;    _messageIdentifier = OsEng.networkEngine().identifier(fullName);    std::vector<char> buffer(1024);    size_t currentWriteLocation = 0;    // Protocol:    // 4 bytes: Total number of bytes sent    // 1 byte : Number of Targets (i)    // i times: 1 byte (id), 1 byte (length j of name), j bytes (name)    // 1 byte : Number of Instruments (i)    // i times: 1 byte (id), 1 byte (length j of name), j bytes (name)    // 4 byte: Number (n) of images    // n times: 8 byte (beginning time), 8 byte (ending time), 1 byte (target id), 2 byte (instrument id)    std::map<std::string, uint8_t> targetMap;    uint8_t currentTargetId = 0;    for (auto target : _subsetMap) {        if (targetMap.find(target.first) == targetMap.end())            targetMap[target.first] = currentTargetId++;    }    std::map<std::string, uint16_t> instrumentMap;    uint16_t currentInstrumentId = 1;    for (auto target : _subsetMap) {        for (auto image : target.second._subset) {            for (auto instrument : image.activeInstruments) {                if (instrumentMap.find(instrument) == instrumentMap.end()) {                    instrumentMap[instrument] = currentInstrumentId;                    currentInstrumentId = currentInstrumentId << 1;                }            }        }    }    writeToBuffer(buffer, currentWriteLocation, uint8_t(targetMap.size()));    for (const std::pair<std::string, uint8_t>& p : targetMap) {        writeToBuffer(buffer, currentWriteLocation, p.second);        writeToBuffer(buffer, currentWriteLocation, p.first);    }    writeToBuffer(buffer, currentWriteLocation, uint8_t(instrumentMap.size()));    for (const std::pair<std::string, uint16_t>& p : instrumentMap) {        writeToBuffer(buffer, currentWriteLocation, p.second);        writeToBuffer(buffer, currentWriteLocation, p.first);    }    uint32_t allImages = 0;    for (auto target : _subsetMap)        allImages += static_cast<uint32_t>(target.second._subset.size());    writeToBuffer(buffer, currentWriteLocation, allImages);    for (auto target : _subsetMap){        for (auto image : target.second._subset){            writeToBuffer(buffer, currentWriteLocation, image.timeRange.start);            writeToBuffer(buffer, currentWriteLocation, image.timeRange.end);            std::string timeBegin = SpiceManager::ref().dateFromEphemerisTime(image.timeRange.start);            std::string timeEnd = SpiceManager::ref().dateFromEphemerisTime(image.timeRange.end);            writeToBuffer(buffer, currentWriteLocation, timeBegin);            writeToBuffer(buffer, currentWriteLocation, timeEnd);            uint8_t targetId = targetMap[target.first];            writeToBuffer(buffer, currentWriteLocation, targetId);            uint16_t totalInstrumentId = 0;            if (image.activeInstruments.empty()) {                LERROR("Image had no active instruments");            }            for (auto instrument : image.activeInstruments) {                uint16_t thisInstrumentId = instrumentMap[instrument];                totalInstrumentId |= thisInstrumentId;            }            writeToBuffer(buffer, currentWriteLocation, totalInstrumentId);        }    }    union {        uint32_t value;        std::array<char, sizeof(uint32_t)> data;    } sizeBuffer;    sizeBuffer.value = static_cast<uint32_t>(currentWriteLocation);    buffer.insert(buffer.begin(), sizeBuffer.data.begin(), sizeBuffer.data.end());    currentWriteLocation += sizeof(uint32_t);    buffer.resize(currentWriteLocation);    //OsEng.networkEngine()->publishMessage(PlaybookIdentifier, buffer);    OsEng.networkEngine().setInitialConnectionMessage(_messageIdentifier, buffer);}

void PtexMainWriter::finish(){    // do nothing if there's no new data to write    if (!_hasNewData) return;    // copy missing faces from _reader    if (_reader) {	for (int i = 0, nfaces = _header.nfaces; i < nfaces; i++) {	    if (_faceinfo[i].flags == uint8_t(-1)) {		// copy face data                const Ptex::FaceInfo& info = _reader->getFaceInfo(i);                int size = _pixelSize * info.res.size();                if (info.isConstant()) {                    PtexPtr<PtexFaceData> data ( _reader->getData(i) );                    if (data) {                        writeConstantFace(i, info, data->getData());                    }                } else {                    void* data = malloc(size);                    _reader->getData(i, data, 0);                    writeFace(i, info, data, 0);                    free(data);                }	    }	}    }    else {	// just flag missing faces as constant (black)	for (int i = 0, nfaces = _header.nfaces; i < nfaces; i++) {	    if (_faceinfo[i].flags == uint8_t(-1))		_faceinfo[i].flags = FaceInfo::flag_constant;	}    }    // write reductions to tmp file    if (_genmipmaps)	generateReductions();    // flag faces w/ constant neighborhoods    flagConstantNeighorhoods();    // update header    _header.nlevels = uint16_t(_levels.size());    _header.nfaces = uint32_t(_faceinfo.size());    // create new file    FILE* newfp = fopen(_newpath.c_str(), "wb+");    if (!newfp) {	setError(fileError("Can't write to ptex file: ", _newpath.c_str()));	return;    }    // write blank header (to fill in later)    writeBlank(newfp, HeaderSize);    writeBlank(newfp, ExtHeaderSize);    // write compressed face info block    _header.faceinfosize = writeZipBlock(newfp, &_faceinfo[0],					 sizeof(FaceInfo)*_header.nfaces);    // write compressed const data block    _header.constdatasize = writeZipBlock(newfp, &_constdata[0], int(_constdata.size()));    // write blank level info block (to fill in later)    FilePos levelInfoPos = ftello(newfp);    writeBlank(newfp, LevelInfoSize * _header.nlevels);    // write level data blocks (and record level info)    std::vector<LevelInfo> levelinfo(_header.nlevels);    for (int li = 0; li < _header.nlevels; li++)    {	LevelInfo& info = levelinfo[li];	LevelRec& level = _levels[li];	int nfaces = int(level.fdh.size());	info.nfaces = nfaces;	// output compressed level data header	info.levelheadersize = writeZipBlock(newfp, &level.fdh[0],					     sizeof(FaceDataHeader)*nfaces);	info.leveldatasize = info.levelheadersize;	// copy level data from tmp file	for (int fi = 0; fi < nfaces; fi++)	    info.leveldatasize += copyBlock(newfp, _tmpfp, level.pos[fi],					    level.fdh[fi].blocksize());	_header.leveldatasize += info.leveldatasize;    }    rewind(_tmpfp);    // write meta data (if any)    if (!_metadata.empty())	writeMetaData(newfp);    // update extheader for edit data position    _extheader.editdatapos = ftello(newfp);    // rewrite level info block    fseeko(newfp, levelInfoPos, SEEK_SET);    _header.levelinfosize = writeBlock(newfp, &levelinfo[0], LevelInfoSize*_header.nlevels);    // rewrite header    fseeko(newfp, 0, SEEK_SET);//.........这里部分代码省略.........

	void vertexPack(const float _input[4], bool _inputNormalized, Attrib::Enum _attr, const VertexDecl& _decl, void* _data, uint32_t _index)	{		if (!_decl.has(_attr) )		{			return;		}		uint32_t stride = _decl.getStride();		uint8_t* data = (uint8_t*)_data + _index*stride + _decl.getOffset(_attr);		uint8_t num;		AttribType::Enum type;		bool normalized;		bool asInt;		_decl.decode(_attr, num, type, normalized, asInt);		switch (type)		{		default:		case AttribType::Uint8:			{				uint8_t* packed = (uint8_t*)data;				if (_inputNormalized)				{					if (asInt)					{						switch (num)						{						default: *packed++ = uint8_t(*_input++ * 127.0f + 128.0f);						case 3:  *packed++ = uint8_t(*_input++ * 127.0f + 128.0f);						case 2:  *packed++ = uint8_t(*_input++ * 127.0f + 128.0f);						case 1:  *packed++ = uint8_t(*_input++ * 127.0f + 128.0f);						}					}					else					{						switch (num)						{						default: *packed++ = uint8_t(*_input++ * 255.0f);						case 3:  *packed++ = uint8_t(*_input++ * 255.0f);						case 2:  *packed++ = uint8_t(*_input++ * 255.0f);						case 1:  *packed++ = uint8_t(*_input++ * 255.0f);						}					}				}				else				{					switch (num)					{					default: *packed++ = uint8_t(*_input++);					case 3:  *packed++ = uint8_t(*_input++);					case 2:  *packed++ = uint8_t(*_input++);					case 1:  *packed++ = uint8_t(*_input++);					}				}			}			break;		case AttribType::Uint10:			{				uint32_t packed = 0;				if (_inputNormalized)				{					if (asInt)					{						switch (num)						{						default:						case 3:                packed |= uint32_t(*_input++ * 511.0f + 512.0f);						case 2: packed <<= 10; packed |= uint32_t(*_input++ * 511.0f + 512.0f);						case 1: packed <<= 10; packed |= uint32_t(*_input++ * 511.0f + 512.0f);						}					}					else					{						switch (num)						{						default:						case 3:                packed |= uint32_t(*_input++ * 1023.0f);						case 2: packed <<= 10; packed |= uint32_t(*_input++ * 1023.0f);						case 1: packed <<= 10; packed |= uint32_t(*_input++ * 1023.0f);						}					}				}				else				{					switch (num)					{					default:					case 3:                packed |= uint32_t(*_input++);					case 2: packed <<= 10; packed |= uint32_t(*_input++);					case 1: packed <<= 10; packed |= uint32_t(*_input++);					}				}				*(uint32_t*)data = packed;			}			break;		case AttribType::Int16:			{//.........这里部分代码省略.........

static void *worker(void *blks) {	// State variables	uint64_t lowesthash[8];	pthread_mutex_lock(&mutex);	memcpy(lowesthash, global_lowest_hash, sizeof(lowesthash));	pthread_mutex_unlock(&mutex);	uint8_t (*blocks)[NUM_CH][8] = (uint8_t (*)[NUM_CH][8])blks;		for (long i = 0; ; i++) {		// Accumulate status		if (i >= iters_per_accumulate) {			pthread_mutex_lock(&mutex);			total_iterations += i;			pthread_mutex_unlock(&mutex);			i = 0;		}				// Do hashing		uint64_t hashes[8][NUM_CH];		memcpy(hashes, INITIAL_STATES, sizeof(hashes));		sha512_compress_dual(hashes, blocks);				// Compare with lowest hash		if (hashes[0][0] <= lowesthash[0] || hashes[0][1] <= lowesthash[0]) {  // Assumes NUM_CH = 2			pthread_mutex_lock(&mutex);			for (int ch = 0; ch < NUM_CH; ch++) {				if (compare_hashes(hashes, ch, global_lowest_hash) < 0) {					char message[MSG_LEN + 1];					get_message(blocks, ch, message);					fprintf(stdout, "%016" PRIx64 "%016" PRIx64 "%016" PRIx64 "%016" PRIx64 "%016" PRIx64 "%016" PRIx64 "%016" PRIx64 "%016" PRIx64 " %s/n",						hashes[0][ch], hashes[1][ch], hashes[2][ch], hashes[3][ch], hashes[4][ch], hashes[5][ch], hashes[6][ch], hashes[7][ch], message);					if (prev_print_type == 1)						fprintf(stderr, "    ");					fprintf(stderr, "%016" PRIx64 "%016" PRIx64 "... %s/n", hashes[0][ch], hashes[1][ch], message);					fflush(stdout);					fflush(stderr);					for (int j = 0; j < 8; j++)						global_lowest_hash[j] = hashes[j][ch];					prev_print_type = 0;				}			}			for (int j = 0; j < 8; j++)				lowesthash[j] = global_lowest_hash[j];			pthread_mutex_unlock(&mutex);		}				// Increment messages		int j;		for (j = MSG_LEN - 1; j >= 0 && get_byte(blocks, j, 0) >= 'z'; j--) {			for (int ch = 0; ch < NUM_CH; ch++)				set_byte(blocks, j, ch, 'a');		}		if (j < 0)			break;		for (int ch = 0; ch < NUM_CH; ch++)			set_byte(blocks, j, ch, get_byte(blocks, j, ch) + 1);	}	pthread_mutex_lock(&mutex);	finished_threads++;	pthread_mutex_unlock(&mutex);	return NULL;}

// do the whole hash in one callvoid SpookyHashV1::Hash128(    const void *message,    size_t length,    uint64_t *hash1,    uint64_t *hash2){    if (length < sc_bufSize)    {        Short(message, length, hash1, hash2);        return;    }    uint64_t h0,h1,h2,h3,h4,h5,h6,h7,h8,h9,h10,h11;    uint64_t buf[sc_numVars];    uint64_t *end;    union    {        const uint8_t *p8;        uint64_t *p64;        size_t i;    } u;    size_t remainder;    h0=h3=h6=h9  = *hash1;    h1=h4=h7=h10 = *hash2;    h2=h5=h8=h11 = sc_const;    u.p8 = (const uint8_t *)message;    end = u.p64 + (length/sc_blockSize)*sc_numVars;    // handle all whole sc_blockSize blocks of bytes    if (ALLOW_UNALIGNED_READS || ((u.i & 0x7) == 0))    {        while (u.p64 < end)        {            Mix(u.p64, h0,h1,h2,h3,h4,h5,h6,h7,h8,h9,h10,h11);            u.p64 += sc_numVars;        }    }    else    {        while (u.p64 < end)        {            memcpy(buf, u.p64, sc_blockSize);            Mix(buf, h0,h1,h2,h3,h4,h5,h6,h7,h8,h9,h10,h11);            u.p64 += sc_numVars;        }    }    // handle the last partial block of sc_blockSize bytes    remainder = (length - ((const uint8_t *)end-(const uint8_t *)message));    memcpy(buf, end, remainder);    memset(((uint8_t *)buf)+remainder, 0, sc_blockSize-remainder);    ((uint8_t*)buf)[sc_blockSize - 1] = uint8_t(remainder);    Mix(buf, h0,h1,h2,h3,h4,h5,h6,h7,h8,h9,h10,h11);    // do some final mixing    End(h0,h1,h2,h3,h4,h5,h6,h7,h8,h9,h10,h11);    *hash1 = h0;    *hash2 = h1;}

int main(void) {	// Sanity test	if (!self_check()) {		fprintf(stderr, "Self-check failed/n");		return EXIT_FAILURE;	}	benchmark();		// Set up the SHA-512 processed blocks: Message (28 bytes), terminator and padding (96 bytes), length (16 bytes)	uint8_t (*blocks)[16][NUM_CH][8] = calloc(num_threads * 16 * NUM_CH * 8, sizeof(uint8_t));	if (blocks == NULL) {		perror("calloc");		return EXIT_FAILURE;	}	{		struct timespec ts;		clock_gettime(CLOCK_REALTIME, &ts);		uint64_t time = ts.tv_sec * UINT64_C(1000000000) + ts.tv_nsec;				for (int i = 0; i < num_threads; i++) {			for (int ch = 0; ch < NUM_CH; ch++) {				uint8_t (*blks)[NUM_CH][8] = blocks[i];				uint64_t temp = time + i * NUM_CH + ch;				for (int j = 0; j < MSG_LEN / 2; j++, temp /= 26)					set_byte(blks, j, ch, 'a' + temp % 26);				for (int j = 0; j < MSG_LEN / 2; j++)					set_byte(blks, j + MSG_LEN / 2, ch, 'a');				set_byte(blks, MSG_LEN, ch, 0x80);				set_byte(blks, 126, ch, MSG_LEN >> 5);				set_byte(blks, 127, ch, MSG_LEN << 3);			}		}	}		// Initialize initial lowest hash	memset(global_lowest_hash, 0xFF, sizeof(global_lowest_hash));	global_lowest_hash[0] >>= 24;  // Exclude trivial matches		// Launch threads	pthread_t *threads = calloc(num_threads, sizeof(pthread_t));	if (threads == NULL) {		perror("calloc");		return EXIT_FAILURE;	}	for (int i = 0; i < num_threads; i++)		pthread_create(&threads[i], NULL, worker, blocks[i]);		// Print status until threads finish	while (true) {		pthread_mutex_lock(&mutex);		if (finished_threads >= num_threads) {			pthread_mutex_unlock(&mutex);			break;		}				char message[MSG_LEN + 1];		get_message(blocks[0], 0, message);  // Only print thread 0, channel 0		fprintf(stderr, "/rHash trials: %.3f billion (%s)", total_iterations * NUM_CH / 1.0e9, message);		fflush(stderr);		prev_print_type = 1;				pthread_mutex_unlock(&mutex);		sleep(10);	}	fprintf(stderr, "/nSearch space exhausted/n");		// Clean up	for (int i = 0; i < num_threads; i++)		pthread_join(threads[i], NULL);	free(blocks);	free(threads);	return EXIT_SUCCESS;}

    AACEncode::AACEncode(int frequencyInHz, int channelCount, int bitRate)    : m_sentConfig(false)    {                OSStatus result = 0;        char err[5];                AudioStreamBasicDescription in = {0}, out = {0};                        // passing anything except 48000, 44100, and 22050 for mSampleRate results in "!dat"        // OSStatus when querying for kAudioConverterPropertyMaximumOutputPacketSize property        // below        in.mSampleRate = frequencyInHz;        // passing anything except 2 for mChannelsPerFrame results in "!dat" OSStatus when        // querying for kAudioConverterPropertyMaximumOutputPacketSize property below        in.mChannelsPerFrame = channelCount;        in.mBitsPerChannel = 16;        in.mFormatFlags =  kAudioFormatFlagIsSignedInteger | kAudioFormatFlagsNativeEndian | kAudioFormatFlagIsPacked;        in.mFormatID = kAudioFormatLinearPCM;        in.mFramesPerPacket = 1;        in.mBytesPerFrame = in.mBitsPerChannel * in.mChannelsPerFrame / 8;        in.mBytesPerPacket = in.mFramesPerPacket*in.mBytesPerFrame;                out.mFormatID = kAudioFormatMPEG4AAC;        out.mFormatFlags = 0;        out.mFramesPerPacket = kSamplesPerFrame;        out.mSampleRate = frequencyInHz;        out.mChannelsPerFrame = channelCount;                UInt32 outputBitrate = bitRate; // 128 kbps        UInt32 propSize = sizeof(outputBitrate);        UInt32 outputPacketSize = 0;        AudioClassDescription requestedCodecs[2] = {            {                kAudioEncoderComponentType,                kAudioFormatMPEG4AAC,                kAppleSoftwareAudioCodecManufacturer            },            {                kAudioEncoderComponentType,                kAudioFormatMPEG4AAC,                kAppleHardwareAudioCodecManufacturer            }        };                result = AudioConverterNewSpecific(&in, &out, 2, requestedCodecs, &m_audioConverter);        if(result == noErr) {                    result = AudioConverterSetProperty(m_audioConverter, kAudioConverterEncodeBitRate, propSize, &outputBitrate);        }        if(result == noErr) {            result = AudioConverterGetProperty(m_audioConverter, kAudioConverterPropertyMaximumOutputPacketSize, &propSize, &outputPacketSize);        }                if(result == noErr) {            m_outputPacketMaxSize = outputPacketSize;                        m_bytesPerSample = 2 * channelCount;                        uint8_t sampleRateIndex = 0;            switch(frequencyInHz) {                case 48000:                    sampleRateIndex = 3;                    break;                case 44100:                    sampleRateIndex = 4;                    break;                case 22050:                    sampleRateIndex = 7;                    break;                case 11025:                    sampleRateIndex = 10;                    break;                case 8000:                    sampleRateIndex = 11;                    break;                default:                    sampleRateIndex = 15;            }            makeAsc(sampleRateIndex, uint8_t(channelCount));        } else {            std::cerr << "Error setting up audio encoder " << result << std::endl ;        }    }