/*------------------------------------------------------------------------------ H264FillerSei() Filler payload SEI message. Requested filler payload size could be huge. Use of temporary stream buffer is not needed, because size is know. ------------------------------------------------------------------------------*/ void H264FillerSei(stream_s * sp, sei_s * sei, i32 cnt) { i32 i = cnt; ASSERT(sp != NULL && sei != NULL); H264NalUnitHdr(sp, 0, SEI, sei->byteStream); H264NalBits(sp, SEI_FILLER_PAYLOAD, 8); COMMENT("last_payload_type_byte"); while(cnt >= 255) { H264NalBits(sp, 0xFF, 0x8); COMMENT("ff_byte"); cnt -= 255; } H264NalBits(sp, cnt, 8); COMMENT("last_payload_size_byte"); for(; i > 0; i--) { H264NalBits(sp, 0xFF, 8); COMMENT("filler ff_byte"); } H264RbspTrailingBits(sp); }
void output_mm_defines(void) { COMMENT("Size of struct page"); DEFINE(STRUCT_PAGE_SIZE, sizeof(struct page)); BLANK(); COMMENT("Linux mm_struct offsets."); OFFSET(MM_USERS, mm_struct, mm_users); OFFSET(MM_PGD, mm_struct, pgd); OFFSET(MM_CONTEXT, mm_struct, context); BLANK(); DEFINE(_PAGE_SIZE, PAGE_SIZE); DEFINE(_PAGE_SHIFT, PAGE_SHIFT); BLANK(); DEFINE(_PGD_T_SIZE, sizeof(pgd_t)); DEFINE(_PTE_T_SIZE, sizeof(pte_t)); BLANK(); DEFINE(_PGD_ORDER, PGD_ORDER); DEFINE(_PTE_ORDER, PTE_ORDER); BLANK(); DEFINE(_PGDIR_SHIFT, PGDIR_SHIFT); BLANK(); DEFINE(_PTRS_PER_PGD, PTRS_PER_PGD); DEFINE(_PTRS_PER_PTE, PTRS_PER_PTE); BLANK(); }
/*------------------------------------------------------------------------------ VideoSignalType ------------------------------------------------------------------------------*/ void VideoSignalType(stream_s * stream, videoSignalType_s * vst) { if(vst->videoSignalType == ENCHW_YES) { EncPutBits(stream, 1, 1); COMMENT("Video Signal Type"); EncPutBits(stream, vst->videoFormat, 3); COMMENT("Video Format"); EncPutBits(stream, vst->videoRange, 1); COMMENT("Video Range"); if(vst->colourDescription == ENCHW_YES) { EncPutBits(stream, 1, 1); COMMENT("Colour Description"); EncPutBits(stream, vst->colourPrimaries, 8); COMMENT("Colour Primaries"); EncPutBits(stream, vst->transferCharacteristics, 8); COMMENT("Transfer Characteristics"); EncPutBits(stream, vst->matrixCoefficients, 8); COMMENT("Matrix Coefficients"); } else { EncPutBits(stream, 0, 1); COMMENT("Colour Description"); } } else { EncPutBits(stream, 0, 1); COMMENT("Video Signal Type"); } return; }
/* This function is not intended to be executed. It is needed to provide * the numeric values of the needed offsets. */ void kedr_offsets_holder(void) { /* kedr_local_storage */ COMMENT("Offsets of the fields in struct kedr_local_storage"); /* Register spill slots */ DEFINE(KEDR_LSTORAGE_ax, KEDR_OFFSET_LS_REG(INAT_REG_CODE_AX)); DEFINE(KEDR_LSTORAGE_cx, KEDR_OFFSET_LS_REG(INAT_REG_CODE_CX)); DEFINE(KEDR_LSTORAGE_dx, KEDR_OFFSET_LS_REG(INAT_REG_CODE_DX)); DEFINE(KEDR_LSTORAGE_bx, KEDR_OFFSET_LS_REG(INAT_REG_CODE_BX)); DEFINE(KEDR_LSTORAGE_sp, KEDR_OFFSET_LS_REG(INAT_REG_CODE_SP)); DEFINE(KEDR_LSTORAGE_bp, KEDR_OFFSET_LS_REG(INAT_REG_CODE_BP)); DEFINE(KEDR_LSTORAGE_si, KEDR_OFFSET_LS_REG(INAT_REG_CODE_SI)); DEFINE(KEDR_LSTORAGE_di, KEDR_OFFSET_LS_REG(INAT_REG_CODE_DI)); #ifdef CONFIG_X86_64 DEFINE(KEDR_LSTORAGE_r8, KEDR_OFFSET_LS_REG(INAT_REG_CODE_8)); DEFINE(KEDR_LSTORAGE_r9, KEDR_OFFSET_LS_REG(INAT_REG_CODE_9)); DEFINE(KEDR_LSTORAGE_r10, KEDR_OFFSET_LS_REG(INAT_REG_CODE_10)); DEFINE(KEDR_LSTORAGE_r11, KEDR_OFFSET_LS_REG(INAT_REG_CODE_11)); DEFINE(KEDR_LSTORAGE_r12, KEDR_OFFSET_LS_REG(INAT_REG_CODE_12)); DEFINE(KEDR_LSTORAGE_r13, KEDR_OFFSET_LS_REG(INAT_REG_CODE_13)); DEFINE(KEDR_LSTORAGE_r14, KEDR_OFFSET_LS_REG(INAT_REG_CODE_14)); DEFINE(KEDR_LSTORAGE_r15, KEDR_OFFSET_LS_REG(INAT_REG_CODE_15)); #endif /* The array of local values */ OFFSET(KEDR_LSTORAGE_values, kedr_local_storage, values); /* Other fields */ OFFSET(KEDR_LSTORAGE_tid, kedr_local_storage, tid); OFFSET(KEDR_LSTORAGE_fi, kedr_local_storage, fi); OFFSET(KEDR_LSTORAGE_write_mask, kedr_local_storage, write_mask); OFFSET(KEDR_LSTORAGE_info, kedr_local_storage, info); OFFSET(KEDR_LSTORAGE_dest_addr, kedr_local_storage, dest_addr); OFFSET(KEDR_LSTORAGE_temp, kedr_local_storage, temp); OFFSET(KEDR_LSTORAGE_temp1, kedr_local_storage, temp1); OFFSET(KEDR_LSTORAGE_temp_bx, kedr_local_storage, temp_bx); OFFSET(KEDR_LSTORAGE_temp_bp, kedr_local_storage, temp_bp); OFFSET(KEDR_LSTORAGE_ret_val, kedr_local_storage, ret_val); OFFSET(KEDR_LSTORAGE_ret_val_high, kedr_local_storage, ret_val_high); OFFSET(KEDR_LSTORAGE_ret_addr, kedr_local_storage, ret_addr); OFFSET(KEDR_LSTORAGE_temp_aux, kedr_local_storage, temp_aux); BLANK(); /* kedr_call_info */ COMMENT("Offsets of the fields in struct kedr_call_info"); OFFSET(KEDR_CALL_INFO_pc, kedr_call_info, pc); OFFSET(KEDR_CALL_INFO_target, kedr_call_info, target); OFFSET(KEDR_CALL_INFO_repl, kedr_call_info, repl); OFFSET(KEDR_CALL_INFO_pre_handler, kedr_call_info, pre_handler); OFFSET(KEDR_CALL_INFO_post_handler, kedr_call_info, post_handler); }
/*------------------------------------------------------------------------------ Function name: EncJpegRestartInterval Functional description: Sets DRI header data Inputs: Outputs: ------------------------------------------------------------------------------*/ void EncJpegRestartInterval(stream_s * stream, jpegData_s * data) { if(data->restart.Ri != 0) { EncJpegHeaderPutBits(stream, DRI, 16); COMMENT("DRI"); data->restart.Lr = 4; EncJpegHeaderPutBits(stream, data->restart.Lr, 16); COMMENT("Lr"); EncJpegHeaderPutBits(stream, data->restart.Ri, 16); COMMENT("Rq"); } }
void output_thread_defines(void) { COMMENT("MIPS specific thread_struct offsets."); OFFSET(THREAD_REG16, task_struct, thread.reg16); OFFSET(THREAD_REG17, task_struct, thread.reg17); OFFSET(THREAD_REG18, task_struct, thread.reg18); OFFSET(THREAD_REG19, task_struct, thread.reg19); OFFSET(THREAD_REG20, task_struct, thread.reg20); OFFSET(THREAD_REG21, task_struct, thread.reg21); OFFSET(THREAD_REG22, task_struct, thread.reg22); OFFSET(THREAD_REG23, task_struct, thread.reg23); OFFSET(THREAD_REG29, task_struct, thread.reg29); OFFSET(THREAD_REG30, task_struct, thread.reg30); OFFSET(THREAD_REG31, task_struct, thread.reg31); OFFSET(THREAD_STATUS, task_struct, thread.cp0_status); #ifdef CONFIG_CPU_SUPPORTS_VECTOR_COPROCESSOR OFFSET(THREAD_VPU, task_struct, thread.vpu); #endif OFFSET(THREAD_FPU, task_struct, thread.fpu); OFFSET(THREAD_BVADDR, task_struct, \ thread.cp0_badvaddr); OFFSET(THREAD_BUADDR, task_struct, \ thread.cp0_baduaddr); OFFSET(THREAD_ECODE, task_struct, \ thread.error_code); OFFSET(THREAD_TRAMP, task_struct, \ thread.irix_trampoline); OFFSET(THREAD_OLDCTX, task_struct, \ thread.irix_oldctx); BLANK(); }
int skipWhiteSpace( UCHAR stream ) { int c; do { c = GET(stream); if (WHITESPACE(c) || c == ESCH) { if (c == ESCH) { c = GET(stream); if (!WHITESPACE(c)) { // push char back out, return esch UngetTxtChr(c, file); c = ESCH; break; } } colZero = FALSE; // we've moved past col 0 } if (c == '\\') c = skipBackSlash(c, stream); } while(WHITESPACE(c)); if (COMMENT(c,colZero,init)) { skipComments(stream); // current char is always c = '\n'; // \n after comments colZero = TRUE; // always in col 0 after a comment } return(c); // true if we're in col 0 }
void output_thread_defines(void) { COMMENT("SCORE specific thread_struct offsets."); OFFSET(THREAD_REG0, task_struct, thread.reg0); OFFSET(THREAD_REG2, task_struct, thread.reg2); OFFSET(THREAD_REG3, task_struct, thread.reg3); OFFSET(THREAD_REG12, task_struct, thread.reg12); OFFSET(THREAD_REG13, task_struct, thread.reg13); OFFSET(THREAD_REG14, task_struct, thread.reg14); OFFSET(THREAD_REG15, task_struct, thread.reg15); OFFSET(THREAD_REG16, task_struct, thread.reg16); OFFSET(THREAD_REG17, task_struct, thread.reg17); OFFSET(THREAD_REG18, task_struct, thread.reg18); OFFSET(THREAD_REG19, task_struct, thread.reg19); OFFSET(THREAD_REG20, task_struct, thread.reg20); OFFSET(THREAD_REG21, task_struct, thread.reg21); OFFSET(THREAD_REG29, task_struct, thread.reg29); OFFSET(THREAD_PSR, task_struct, thread.cp0_psr); OFFSET(THREAD_EMA, task_struct, thread.cp0_ema); OFFSET(THREAD_BADUADDR, task_struct, thread.cp0_baduaddr); OFFSET(THREAD_ECODE, task_struct, thread.error_code); OFFSET(THREAD_TRAPNO, task_struct, thread.trap_no); BLANK(); }
std::string GCodeWriter::_retract(double length, double restart_extra, const std::string &comment) { std::ostringstream gcode; /* If firmware retraction is enabled, we use a fake value of 1 since we ignore the actual configured retract_length which might be 0, in which case the retraction logic gets skipped. */ if (this->config.use_firmware_retraction) length = 1; // If we use volumetric E values we turn lengths into volumes */ if (this->config.use_volumetric_e) { double d = this->_extruder->filament_diameter(); double area = d * d * PI/4; length = length * area; restart_extra = restart_extra * area; } double dE = this->_extruder->retract(length, restart_extra); if (dE != 0) { if (this->config.use_firmware_retraction) { gcode << "G10 ; retract\n"; } else { gcode << "G1 " << this->_extrusion_axis << E_NUM(this->_extruder->E) << " F" << this->_extruder->retract_speed_mm_min; COMMENT(comment); gcode << "\n"; } } if (FLAVOR_IS(gcfMakerWare)) gcode << "M103 ; extruder off\n"; return gcode.str(); }
int main () { INIT_INFO ("SolveSquareEquation"); COMMENT ("Enter a, b, c for ax^2 + bx + c = 0:"); double a = 0, b = 0, c = 0; if (!INPUT (a) || !INPUT (b) || !INPUT(c)) return 1; double x1 = 0, x2 = 0; int nRoots = SolveSquareEquation(a, b, c, &x1, &x2); switch (nRoots) { case 0: printf ("#No roots\n"); break; case 1: printf ("#One root: x1 = %lg\n", x1); break; case 2: printf ("#Two roots: x1 = %lg, x2 = %lg\n", x1, x2); break; case INFINITE_ROOTS: printf ("#Infinite number of roots\n"); break; } return 0; }
void output_octeon_cop2_state_defines(void) { COMMENT("Octeon specific octeon_cop2_state offsets."); OFFSET(OCTEON_CP2_CRC_IV, octeon_cop2_state, cop2_crc_iv); OFFSET(OCTEON_CP2_CRC_LENGTH, octeon_cop2_state, cop2_crc_length); OFFSET(OCTEON_CP2_CRC_POLY, octeon_cop2_state, cop2_crc_poly); OFFSET(OCTEON_CP2_LLM_DAT, octeon_cop2_state, cop2_llm_dat); OFFSET(OCTEON_CP2_3DES_IV, octeon_cop2_state, cop2_3des_iv); OFFSET(OCTEON_CP2_3DES_KEY, octeon_cop2_state, cop2_3des_key); OFFSET(OCTEON_CP2_3DES_RESULT, octeon_cop2_state, cop2_3des_result); OFFSET(OCTEON_CP2_AES_INP0, octeon_cop2_state, cop2_aes_inp0); OFFSET(OCTEON_CP2_AES_IV, octeon_cop2_state, cop2_aes_iv); OFFSET(OCTEON_CP2_AES_KEY, octeon_cop2_state, cop2_aes_key); OFFSET(OCTEON_CP2_AES_KEYLEN, octeon_cop2_state, cop2_aes_keylen); OFFSET(OCTEON_CP2_AES_RESULT, octeon_cop2_state, cop2_aes_result); OFFSET(OCTEON_CP2_GFM_MULT, octeon_cop2_state, cop2_gfm_mult); OFFSET(OCTEON_CP2_GFM_POLY, octeon_cop2_state, cop2_gfm_poly); OFFSET(OCTEON_CP2_GFM_RESULT, octeon_cop2_state, cop2_gfm_result); OFFSET(OCTEON_CP2_HSH_DATW, octeon_cop2_state, cop2_hsh_datw); OFFSET(OCTEON_CP2_HSH_IVW, octeon_cop2_state, cop2_hsh_ivw); OFFSET(OCTEON_CP2_SHA3, octeon_cop2_state, cop2_sha3); OFFSET(THREAD_CP2, task_struct, thread.cp2); OFFSET(THREAD_CVMSEG, task_struct, thread.cvmseg.cvmseg); BLANK(); }
std::string GCodeWriter::travel_to_xyz(const Pointf3 &point, const std::string &comment) { /* If target Z is lower than current Z but higher than nominal Z we don't perform the Z move but we only move in the XY plane and adjust the nominal Z by reducing the lift amount that will be used for unlift. */ if (!this->will_move_z(point.z)) { double nominal_z = this->_pos.z - this->_lifted; this->_lifted = this->_lifted - (point.z - nominal_z); return this->travel_to_xy(point); } /* In all the other cases, we perform an actual XYZ move and cancel the lift. */ this->_lifted = 0; this->_pos = point; std::ostringstream gcode; gcode << "G1 X" << XYZF_NUM(point.x) << " Y" << XYZF_NUM(point.y) << " Z" << XYZF_NUM(point.z) << " F" << XYZF_NUM(this->config.travel_speed.value * 60.0); COMMENT(comment); gcode << "\n"; return gcode.str(); }
main(int argc,char *argv[]) { if (argc != 2) { fprintf(stderr,"usage: %s name-for-package\n", argv[0]); exit(1); } NEWLINE(); PUTS("package "); PUTS(argv[1]); PUTS(" : Cc_Info =\n"); PUTS("\tstruct\n"); PUTS("\t\t");COMMENT("all sizes in bytes"); NEWLINE(); PUTVAL("intSzB", sizeof(int)); PUTVAL("shortSzB", sizeof(short)); PUTVAL("longSzB", sizeof(long)); NEWLINE(); PUTVAL("charSzB", sizeof(char)); NEWLINE(); PUTVAL("floatSzB", sizeof(float)); PUTVAL("doubleSzB", sizeof(double)); NEWLINE(); PUTVAL("ptrSzB", sizeof(int *)); NEWLINE(); PUTVAL("unionAlign", sizeof(int *)); PUTVAL("structAlign", sizeof(int *)); NEWLINE(); PUTS("\tend "); PUTS("/* package "); PUTS(argv[1]); PUTS(" */\n"); exit(0); }
void output_thread_defines(void) { COMMENT("MIPS specific thread_struct offsets."); OFFSET(THREAD_REG16, task_struct, thread.reg16); OFFSET(THREAD_REG17, task_struct, thread.reg17); OFFSET(THREAD_REG18, task_struct, thread.reg18); OFFSET(THREAD_REG19, task_struct, thread.reg19); OFFSET(THREAD_REG20, task_struct, thread.reg20); OFFSET(THREAD_REG21, task_struct, thread.reg21); OFFSET(THREAD_REG22, task_struct, thread.reg22); OFFSET(THREAD_REG23, task_struct, thread.reg23); OFFSET(THREAD_REG29, task_struct, thread.reg29); OFFSET(THREAD_REG30, task_struct, thread.reg30); OFFSET(THREAD_REG31, task_struct, thread.reg31); OFFSET(THREAD_STATUS, task_struct, thread.cp0_status); OFFSET(THREAD_FPU, task_struct, thread.fpu); OFFSET(THREAD_BVADDR, task_struct, \ thread.cp0_badvaddr); OFFSET(THREAD_BUADDR, task_struct, \ thread.cp0_baduaddr); OFFSET(THREAD_ECODE, task_struct, \ thread.error_code); BLANK(); }
/*------------------------------------------------------------------------------ H264BufferingSei() Buffering period SEI message. ------------------------------------------------------------------------------*/ void H264BufferingSei(stream_s * sp, sei_s * sei) { u8 *pPayloadSizePos; u32 startByteCnt; ASSERT(sei != NULL); if(sei->hrd == ENCHW_NO) { return; } H264NalBits(sp, SEI_BUFFERING_PERIOD, 8); COMMENT("last_payload_type_byte"); pPayloadSizePos = sp->stream; H264NalBits(sp, 0xFF, 8); /* this will be updated after we know exact payload size */ COMMENT("last_payload_size_byte"); startByteCnt = sp->byteCnt; sp->emulCnt = 0; /* count emul_3_byte for this payload */ H264ExpGolombUnsigned(sp, sei->seqId); COMMENT("seq_parameter_set_id"); H264NalBits(sp, sei->icrd, sei->icrdLen); COMMENT("initial_cpb_removal_delay"); H264NalBits(sp, sei->icrdo, sei->icrdoLen); COMMENT("initial_cpb_removal_delay_offset"); if(sp->bufferedBits) { H264RbspTrailingBits(sp); } { u32 payload_size; payload_size = sp->byteCnt - startByteCnt - sp->emulCnt; *pPayloadSizePos = payload_size; } /* reset cpb_removal_delay */ sei->crd = 0; }
/*------------------------------------------------------------------------------ Function name: EncJpegCOMHeader Functional description: Sets COM header data Inputs: Outputs: ------------------------------------------------------------------------------*/ void EncJpegCOMHeader(stream_s * stream, jpegData_s * data) { u32 j; EncJpegHeaderPutBits(stream, COM, 16); COMMENT("COM"); EncJpegHeaderPutBits(stream, 2 + data->com.comLen, 16); COMMENT("Lc"); for(j = 0; j < data->com.comLen; j++) { /* Qk table 0 */ EncJpegHeaderPutBits(stream, data->com.pComment[j], 8); COMMENT("COM data"); } }
void output_sc32_defines(void) { COMMENT("Linux 32-bit sigcontext offsets."); OFFSET(SC32_FPREGS, sigcontext32, sc_fpregs); OFFSET(SC32_FPC_CSR, sigcontext32, sc_fpc_csr); OFFSET(SC32_FPC_EIR, sigcontext32, sc_fpc_eir); BLANK(); }
void output_irq_cpustat_t_defines(void) { COMMENT("Linux irq_cpustat_t offsets."); DEFINE(IC_SOFTIRQ_PENDING, offsetof(irq_cpustat_t, __softirq_pending)); DEFINE(IC_IRQ_CPUSTAT_T, sizeof(irq_cpustat_t)); BLANK(); }
/*------------------------------------------------------------------------------ H264NalUnit ------------------------------------------------------------------------------*/ void H264NalUnitHdr(stream_s * stream, i32 nalRefIdc, nalUnitType_e nalUnitType, true_e byteStream) { if(byteStream == ENCHW_YES) { H264PutBits(stream, 0, 8); COMMENT("BYTE STREAM: leadin_zero_8bits"); H264PutBits(stream, 0, 8); COMMENT("BYTE STREAM: Start_code_prefix"); H264PutBits(stream, 0, 8); COMMENT("BYTE STREAM: Start_code_prefix"); H264PutBits(stream, 1, 8); COMMENT("BYTE STREAM: Start_code_prefix"); } H264PutBits(stream, 0, 1); COMMENT("forbidden_zero_bit"); H264PutBits(stream, nalRefIdc, 2); COMMENT("nal_ref_idc"); H264PutBits(stream, (i32) nalUnitType, 5); COMMENT("nal_unit_type"); stream->zeroBytes = 0; /* we start new counter for zero bytes */ return; }
int main() { INIT_INFO ("SortByLines"); char filename[MAX_FILENAME] = {};//"Onegin.txt"; char savename[MAX_FILENAME] = {};//"NewOnegin.txt";//{}; COMMENT ("File to read from:"); printf (">"); scanf ("%s", filename); COMMENT ("File to save to:"); printf (">"); scanf ("%s", savename); StringList strings = {}; stringlist_init(&strings); if (stringlist_construct (&strings, filename) == ERROR) { perror("General error"); return 1; } // stringlist_dump(&strings); StringList sorted = {};//NOINIT; // = { NOINIT_POISON }; stringlist_init(&sorted); if (stringlist_construct (&sorted, &strings) == ERROR) { perror("Other error"); return 2; } // stringlist_sort (&sorted); stringlist_back_sort (&sorted); if (stringslist_to_file (&sorted, savename) == ERROR) { perror ("One more error"); return 3; } stringlist_destruct (&sorted); stringlist_destruct (&strings); COMMENT("Done!"); printf ("#Data was successfully saved to %s\n", savename); return 0; }
std::string GCodeWriter::set_speed(double F, const std::string &comment) { std::ostringstream gcode; gcode << "G1 F" << F; COMMENT(comment); gcode << "\n"; return gcode.str(); }
void output_pbe_defines(void) { COMMENT(" Linux struct pbe offsets. "); OFFSET(PBE_ADDRESS, pbe, address); OFFSET(PBE_ORIG_ADDRESS, pbe, orig_address); OFFSET(PBE_NEXT, pbe, next); DEFINE(PBE_SIZE, sizeof(struct pbe)); BLANK(); }
/*------------------------------------------------------------------------------ Function name: EncJpegImageEndReplaceRst Functional description: write EOI over hw set RST Inputs: Outputs: ------------------------------------------------------------------------------*/ void EncJpegImageEndReplaceRst(stream_s * stream, jpegData_s * data) { COMMENT("Replace RST with EOI (slice mode)"); /* write EOI to stream */ stream->stream[0] = 0xFF; stream->stream[1] = 0xD9; stream->stream++; stream->stream++; /* take care of next putbits */ if(data->appn.thumbMode) { stream->stream[0] = 0x0; stream->stream[1] = 0x0; } COMMENT("RST ==> EOI"); }
GraphicElement::GraphicElement( int minInputSz, int maxInputSz, int minOutputSz, int maxOutputSz, QGraphicsItem *parent ) : QGraphicsObject( parent ), label( new QGraphicsTextItem( this ) ) { COMMENT( "Setting flags of elements. ", 4 ); setFlag( QGraphicsItem::ItemIsMovable ); setFlag( QGraphicsItem::ItemIsSelectable ); /* setFlag(QGraphicsItem::ItemSendsScenePositionChanges); */ setFlag( QGraphicsItem::ItemSendsGeometryChanges ); COMMENT( "Setting attributes. ", 4 ); label->hide( ); QFont font( "SansSerif" ); font.setBold( true ); label->setFont( font ); label->setPos( 64, 30 ); label->setParentItem( this ); m_bottomPosition = 64; m_topPosition = 0; m_minInputSz = minInputSz; m_minOutputSz = minOutputSz; m_maxInputSz = maxInputSz; m_maxOutputSz = maxOutputSz; m_changed = true; // m_visited = false; // m_beingVisited = false; m_rotatable = true; m_hasColors = false; m_hasTones = false; m_hasTrigger = false; m_hasFrequency = false; m_hasLabel = false; m_disabled = false; m_outputsOnTop = true; COMMENT( "Including input and output ports.", 4 ); for( int i = 0; i < minInputSz; i++ ) { addInputPort( ); } for( int i = 0; i < minOutputSz; i++ ) { addOutputPort( ); } }
void check_lnet_hdr (void) { CHECK_STRUCT (lnet_hdr_t); CHECK_MEMBER (lnet_hdr_t, dest_nid); CHECK_MEMBER (lnet_hdr_t, src_nid); CHECK_MEMBER (lnet_hdr_t, dest_pid); CHECK_MEMBER (lnet_hdr_t, src_pid); CHECK_MEMBER (lnet_hdr_t, type); CHECK_MEMBER (lnet_hdr_t, payload_length); CHECK_MEMBER (lnet_hdr_t, msg); BLANK_LINE (); COMMENT ("Ack"); CHECK_MEMBER (lnet_hdr_t, msg.ack.dst_wmd); CHECK_MEMBER (lnet_hdr_t, msg.ack.match_bits); CHECK_MEMBER (lnet_hdr_t, msg.ack.mlength); BLANK_LINE (); COMMENT ("Put"); CHECK_MEMBER (lnet_hdr_t, msg.put.ack_wmd); CHECK_MEMBER (lnet_hdr_t, msg.put.match_bits); CHECK_MEMBER (lnet_hdr_t, msg.put.hdr_data); CHECK_MEMBER (lnet_hdr_t, msg.put.ptl_index); CHECK_MEMBER (lnet_hdr_t, msg.put.offset); BLANK_LINE (); COMMENT ("Get"); CHECK_MEMBER (lnet_hdr_t, msg.get.return_wmd); CHECK_MEMBER (lnet_hdr_t, msg.get.match_bits); CHECK_MEMBER (lnet_hdr_t, msg.get.ptl_index); CHECK_MEMBER (lnet_hdr_t, msg.get.src_offset); CHECK_MEMBER (lnet_hdr_t, msg.get.sink_length); BLANK_LINE (); COMMENT ("Reply"); CHECK_MEMBER (lnet_hdr_t, msg.reply.dst_wmd); BLANK_LINE (); COMMENT ("Hello"); CHECK_MEMBER (lnet_hdr_t, msg.hello.incarnation); CHECK_MEMBER (lnet_hdr_t, msg.hello.type); }
/*------------------------------------------------------------------------------ H264UserDataUnregSei() User data unregistered SEI message. ------------------------------------------------------------------------------*/ void H264UserDataUnregSei(stream_s * sp, sei_s * sei) { u32 i, cnt; const u8 * pUserData; ASSERT(sei != NULL); ASSERT(sei->pUserData != NULL); ASSERT(sei->userDataSize >= 16); pUserData = sei->pUserData; cnt = sei->userDataSize; if(sei->userDataEnabled == ENCHW_NO) { return; } H264NalBits(sp, SEI_USER_DATA_UNREGISTERED, 8); COMMENT("last_payload_type_byte"); while(cnt >= 255) { H264NalBits(sp, 0xFF, 0x8); COMMENT("ff_byte"); cnt -= 255; } H264NalBits(sp, cnt, 8); COMMENT("last_payload_size_byte"); /* Write uuid */ for (i = 0; i < 16; i++) { H264NalBits(sp, pUserData[i], 8); COMMENT("uuid_iso_iec_11578_byte"); } /* Write payload */ for (i = 16; i < sei->userDataSize; i++) { H264NalBits(sp, pUserData[i], 8); COMMENT("user_data_payload_byte"); } }
void output_task_defines(void) { COMMENT("SCORE task_struct offsets."); OFFSET(TASK_STATE, task_struct, state); OFFSET(TASK_THREAD_INFO, task_struct, stack); OFFSET(TASK_FLAGS, task_struct, flags); OFFSET(TASK_MM, task_struct, mm); OFFSET(TASK_PID, task_struct, pid); DEFINE(TASK_STRUCT_SIZE, sizeof(struct task_struct)); BLANK(); }
void output_ptreg_defines(void) { COMMENT("MIPS pt_regs offsets."); OFFSET(PT_R0, pt_regs, regs[0]); OFFSET(PT_R1, pt_regs, regs[1]); OFFSET(PT_R2, pt_regs, regs[2]); OFFSET(PT_R3, pt_regs, regs[3]); OFFSET(PT_R4, pt_regs, regs[4]); OFFSET(PT_R5, pt_regs, regs[5]); OFFSET(PT_R6, pt_regs, regs[6]); OFFSET(PT_R7, pt_regs, regs[7]); OFFSET(PT_R8, pt_regs, regs[8]); OFFSET(PT_R9, pt_regs, regs[9]); OFFSET(PT_R10, pt_regs, regs[10]); OFFSET(PT_R11, pt_regs, regs[11]); OFFSET(PT_R12, pt_regs, regs[12]); OFFSET(PT_R13, pt_regs, regs[13]); OFFSET(PT_R14, pt_regs, regs[14]); OFFSET(PT_R15, pt_regs, regs[15]); OFFSET(PT_R16, pt_regs, regs[16]); OFFSET(PT_R17, pt_regs, regs[17]); OFFSET(PT_R18, pt_regs, regs[18]); OFFSET(PT_R19, pt_regs, regs[19]); OFFSET(PT_R20, pt_regs, regs[20]); OFFSET(PT_R21, pt_regs, regs[21]); OFFSET(PT_R22, pt_regs, regs[22]); OFFSET(PT_R23, pt_regs, regs[23]); OFFSET(PT_R24, pt_regs, regs[24]); OFFSET(PT_R25, pt_regs, regs[25]); OFFSET(PT_R26, pt_regs, regs[26]); OFFSET(PT_R27, pt_regs, regs[27]); OFFSET(PT_R28, pt_regs, regs[28]); OFFSET(PT_R29, pt_regs, regs[29]); OFFSET(PT_R30, pt_regs, regs[30]); OFFSET(PT_R31, pt_regs, regs[31]); OFFSET(PT_LO, pt_regs, lo); OFFSET(PT_HI, pt_regs, hi); #ifdef CONFIG_CPU_HAS_SMARTMIPS OFFSET(PT_ACX, pt_regs, acx); #endif OFFSET(PT_EPC, pt_regs, cp0_epc); OFFSET(PT_BVADDR, pt_regs, cp0_badvaddr); OFFSET(PT_STATUS, pt_regs, cp0_status); OFFSET(PT_CAUSE, pt_regs, cp0_cause); #ifdef CONFIG_MIPS_MT_SMTC OFFSET(PT_TCSTATUS, pt_regs, cp0_tcstatus); #endif /* CONFIG_MIPS_MT_SMTC */ #ifdef CONFIG_CPU_CAVIUM_OCTEON OFFSET(PT_MPL, pt_regs, mpl); OFFSET(PT_MTP, pt_regs, mtp); #endif /* CONFIG_CPU_CAVIUM_OCTEON */ DEFINE(PT_SIZE, sizeof(struct pt_regs)); BLANK(); }
void output_pm_defines(void) { COMMENT(" PM offsets. "); #ifdef CONFIG_EVA OFFSET(SSS_SEGCTL0, mips_static_suspend_state, segctl[0]); OFFSET(SSS_SEGCTL1, mips_static_suspend_state, segctl[1]); OFFSET(SSS_SEGCTL2, mips_static_suspend_state, segctl[2]); #endif OFFSET(SSS_SP, mips_static_suspend_state, sp); BLANK(); }
void output_sc_defines(void) { COMMENT("Linux sigcontext offsets."); OFFSET(SC_REGS, sigcontext, sc_regs); OFFSET(SC_FPREGS, sigcontext, sc_fpregs); OFFSET(SC_MDHI, sigcontext, sc_mdhi); OFFSET(SC_MDLO, sigcontext, sc_mdlo); OFFSET(SC_PC, sigcontext, sc_pc); OFFSET(SC_FPC_CSR, sigcontext, sc_fpc_csr); BLANK(); }