static inline unsigned read_u16(void *ss, int stream) { unsigned ret; ret = read_u8(ss, stream); ret |= read_u8(ss, stream)<<8; return ret; }
Uint32 stream::read_vu32() { Uint32 result = read_u8(); if ( ( result & 0x00000080 ) == 0 ) { return result; } result = ( result & 0x0000007F ) | read_u8() << 7; if ( ( result & 0x00004000 ) == 0 ) { return result; } result = ( result & 0x00003FFF ) | read_u8() << 14; if ( ( result & 0x00200000 ) == 0 ) { return result; } result = ( result & 0x001FFFFF ) | read_u8() << 21; if ( ( result & 0x10000000 ) == 0 ) { return result; } result = ( result & 0x0FFFFFFF ) | read_u8() << 28; return result; }
uint16_t read_u16(const unsigned char *p) { uint16_t result; result = (uint16_t) read_u8(p + 0) << 8; result |= (uint16_t) read_u8(p + 1); return result; }
uint32_t read_u32(const unsigned char *p) { uint32_t result; result = (uint32_t) read_u8(p + 0) << 24; result |= (uint32_t) read_u8(p + 1) << 16; result |= (uint32_t) read_u8(p + 2) << 8; result |= (uint32_t) read_u8(p + 3); return result; }
/** * @brief display the DMA results * This function displays the memory locations associated with a DMA transfer * * @param pParams is a pointer to the parameters structure * * @return success/failure * * @note none * ******************************************************************************/ void dmaResults(params_struct *pParams) { xil_printf("Source memory"); xil_printf("\n 0 1 2 3 4 5 6 7 8 9 A B C D E F"); xil_printf("\n----------------------------------------------------------"); read_u8(pParams->pUART, (unsigned char *)pParams->dataSourceLocation, 128, 1); // execute dump xil_printf("\n\nDestination Memory\n"); read_u8(pParams->pUART, (unsigned char *)pParams->dataDestinationLocation, 128, 1); // execute dump xil_printf("\n\n>"); }
int read_u32be(t_stream *stream, uint32_t *nbr) { uint8_t *ptr; int res; ptr = (uint8_t*)nbr; res = read_u8(stream, ptr + 0) && read_u8(stream, ptr + 1) && read_u8(stream, ptr + 2) && read_u8(stream, ptr + 3); if (res) *nbr = ntohl(*nbr); return (res); }
/* Read out a given typed element */ static jvalue read_val(unsigned char **pp, HprofType ty) { jvalue val; static jvalue empty_val; val = empty_val; switch ( ty ) { case 0: case HPROF_ARRAY_OBJECT: case HPROF_NORMAL_OBJECT: val.i = read_id(pp); break; case HPROF_BYTE: case HPROF_BOOLEAN: val.b = read_u1(pp); break; case HPROF_CHAR: case HPROF_SHORT: val.s = read_u2(pp); break; case HPROF_FLOAT: case HPROF_INT: val.i = read_u4(pp); break; case HPROF_DOUBLE: case HPROF_LONG: val.j = read_u8(pp); break; default: HPROF_ERROR(JNI_TRUE, "bad type number"); break; } return val; }
static void do_test_libeprom24x(void) { int value; do { print_menu(); printf("Enter choice : "); scanf("%d",&value); switch(value) { case 1: get_prod_info(); break; case 2: get_last_error(); break; case 3: initialize(); break; case 4: finalize(); break; case 5: read_u8(); break; case 6: read_u16(); break; case 7: read_u32(); break; case 8: read_to_buffer(); break; case 9: write_u8(); break; case 10: write_u16(); break; case 11: write_u32(); break; case 12: write_from_buffer(); break; case 13: erase_chip(); break; case 100: /* Exit */ break; default: printf("Illegal choice!\n"); } } while (value != 100); return; }
void MetroHash128::Finalize(uint8_t * const hash) { // finalize bulk loop, if used if (bytes >= 32) { state.v[2] ^= rotate_right(((state.v[0] + state.v[3]) * k0) + state.v[1], 21) * k1; state.v[3] ^= rotate_right(((state.v[1] + state.v[2]) * k1) + state.v[0], 21) * k0; state.v[0] ^= rotate_right(((state.v[0] + state.v[2]) * k0) + state.v[3], 21) * k1; state.v[1] ^= rotate_right(((state.v[1] + state.v[3]) * k1) + state.v[2], 21) * k0; } // process any bytes remaining in the input buffer const uint8_t * ptr = reinterpret_cast<const uint8_t*>(input.b); const uint8_t * const end = ptr + (bytes % 32); if ((end - ptr) >= 16) { state.v[0] += read_u64(ptr) * k2; ptr += 8; state.v[0] = rotate_right(state.v[0],33) * k3; state.v[1] += read_u64(ptr) * k2; ptr += 8; state.v[1] = rotate_right(state.v[1],33) * k3; state.v[0] ^= rotate_right((state.v[0] * k2) + state.v[1], 45) * k1; state.v[1] ^= rotate_right((state.v[1] * k3) + state.v[0], 45) * k0; } if ((end - ptr) >= 8) { state.v[0] += read_u64(ptr) * k2; ptr += 8; state.v[0] = rotate_right(state.v[0],33) * k3; state.v[0] ^= rotate_right((state.v[0] * k2) + state.v[1], 27) * k1; } if ((end - ptr) >= 4) { state.v[1] += read_u32(ptr) * k2; ptr += 4; state.v[1] = rotate_right(state.v[1],33) * k3; state.v[1] ^= rotate_right((state.v[1] * k3) + state.v[0], 46) * k0; } if ((end - ptr) >= 2) { state.v[0] += read_u16(ptr) * k2; ptr += 2; state.v[0] = rotate_right(state.v[0],33) * k3; state.v[0] ^= rotate_right((state.v[0] * k2) + state.v[1], 22) * k1; } if ((end - ptr) >= 1) { state.v[1] += read_u8 (ptr) * k2; state.v[1] = rotate_right(state.v[1],33) * k3; state.v[1] ^= rotate_right((state.v[1] * k3) + state.v[0], 58) * k0; } state.v[0] += rotate_right((state.v[0] * k0) + state.v[1], 13); state.v[1] += rotate_right((state.v[1] * k1) + state.v[0], 37); state.v[0] += rotate_right((state.v[0] * k2) + state.v[1], 13); state.v[1] += rotate_right((state.v[1] * k3) + state.v[0], 37); bytes = 0; // do any endian conversion here memcpy(hash, state.v, 16); }
static int parse_pnm_header(FILE* fid, int* W, int* H, int* depth, int* maxval) { // P6 == ppm unsigned char p = '\0'; unsigned char n = '\0'; if (read_u8(fid, &p) || read_u8(fid, &n)) { ERROR("Failed to read P* from PNM header"); return -1; } if (p != 'P') { ERROR("File doesn't start with 'P': not pnm."); return -1; } if (n == '6') { // PPM *depth = 3; } else if (n == '5') { // PGM *depth = 1; } else { ERROR("File starts with code \"%c%c\": not understood as pnm.", p,n); return -1; } if (skip_whitespace(fid, 0)) return -1; if (fscanf(fid, "%d", W) != 1) { ERROR("Failed to parse width from PNM header"); return -1; } if (skip_whitespace(fid, 0)) return -1; if (fscanf(fid, "%d", H) != 1) { ERROR("Failed to parse height from PNM header"); return -1; } if (skip_whitespace(fid, 0)) return -1; if (fscanf(fid, "%d", maxval) != 1) { ERROR("Failed to parse maxval from PNM header"); return -1; } if (skip_whitespace(fid, 1)) return -1; return 0; }
static i64 read_header(rzip_control *control, void *ss, uchar *head) { bool err = false; *head = read_u8(control, ss, 0, &err); if (err) return -1; return read_vchars(control, ss, 0, control->chunk_bytes); }
static void read_u8_func(void** state) { uint8_t comp_buf = 0; uint32_t idx = 0; for(uint32_t i = 0; i < CHAR_SIZE; i++) { comp_buf = 'a' + i; assert_int_equal(read_u8(buffer, &idx), comp_buf); } }
void test8(){ int fd = open_file(); u8 * myu8 = malloc(sizeof(u8)); read_u8(fd,myu8); assertTrue_int("U8 Reader",*myu8, 0x49); close(fd); }
u32 xbinary_reader::read(bool& b) { if (_can_read(len_, cursor_, 1)) { xbyte const* ptr = buffer_ + cursor_; cursor_ += 1; b = read_u8(ptr) != 0; return 1; } return 0; }
u32 xbinary_reader::read(u8 & b) { if (_can_read(len_, cursor_, sizeof(b))) { xbyte const* ptr = buffer_ + cursor_; cursor_ += sizeof(b); b = read_u8(ptr); return sizeof(b); } return 0; }
// Return the next startcode or sequence_error_code if not enough // data was left in the bitstream. Also set esstream->bitsleft. // The bitstream pointer shall be moved to the begin of the start // code if found, or to the position where a search would continue // would more data be made available. // Only NULL bytes before the start code are discarded, if a non // NULL byte is encountered esstream->error is set to TRUE and the // function returns sequence_error_code with the pointer set after // that byte. static uint8_t next_start_code(struct bitstream *esstream) { if (esstream->error || esstream->bitsleft < 0) { return 0xB4; } make_byte_aligned(esstream); // Only start looking if there is enough data. Adjust bitsleft. if (esstream->bitsleft < 4*8) { dbg_print(DMT_VERBOSE, "next_start_code: bitsleft %lld < 32\n", esstream->bitsleft); esstream->bitsleft -= 8*4; return 0xB4; } uint8_t tmp; while ((next_u32(esstream)&0x00FFFFFF) != 0x00010000 // LSB 0x000001?? && esstream->bitsleft > 0) { tmp = read_u8(esstream); if (tmp) { dbg_print(DMT_VERBOSE, "next_start_code: Non zero stuffing\n"); esstream->error = 1; return 0xB4; } } if (esstream->bitsleft < 8) { esstream->bitsleft -= 8; dbg_print(DMT_VERBOSE, "next_start_code: bitsleft <= 0\n"); return 0xB4; } else { dbg_print(DMT_VERBOSE, "next_start_code: Found %02X\n", *(esstream->pos+3)); if ( *(esstream->pos+3) == 0xB4 ) { dbg_print(DMT_VERBOSE, "B4: assume bitstream syntax error!\n"); esstream->error = 1; } return *(esstream->pos+3); } }
void main(){ //ouverture int fd ; fd = open("/home/marms/Documents/ASR/C/TP5/x.mp3", O_CREAT | O_RDONLY, 0666 ); if( fd == -1 ){ printf("erreur ouverture\n"); exit(15); } printf("\n====ESSAIS PERMUTE======\n"); u16 *x= (u16*)malloc(sizeof(u16)); *x=0x4244;//BD affiche_u16(x); permut2(x); //DB affiche_u16(x); printf("x, %0x\n",*x); u32* g= (u32*)malloc(sizeof(u32)); *g=0x10203040; permut4(g); printf("g, %0x\n",*g); printf("\n======FIN PERMUTE=======\n"); u8* a = (u8*) malloc(sizeof(u8)); if(! read_u8(fd,a)){ printf("echec3\n");} affiche_u8(a); u16* e = (u16*) malloc(sizeof(u16)); if(! read_u16(fd,e)){ printf("echec3\n");} affiche_u16(e); u32* f = (u32*) malloc(sizeof(u32)); if(! read_u32(fd,f)){ printf("echec4\n");} affiche_u32(f); *h = 0x6d776e6e ; affiche_u32(h); aff_bin((u8*)h); printf("\n"); *h= convert_size(*h); aff_bin((u8*)h); printf("\n"); //fermeture close(fd); }
/* Read a DWARF LEB128 (little-endian base-128) value. */ static bool read_leb128(struct dwbuf *d, uint64_t *v, bool signextend) { unsigned int shift = 0; uint64_t res = 0; uint8_t x; while (shift < 64 && read_u8(d, &x)) { res |= (uint64_t)(x & 0x7f) << shift; shift += 7; if ((x & 0x80) == 0) { if (signextend && shift < 64 && (x & 0x40) != 0) res |= ~(uint64_t)0 << shift; *v = res; return (true); } } return (false); }
int tag_read_id3_header(int fd, id3v2_header_t *header) { if(strcmp("ID3", read_string(fd, header->ID3, 3, 0))) return -1; if(!read_u16(fd, &(header->version))) return -1; // version valide if(header->version > 0x0300) return -1; if(!read_u8(fd, &(header->flags))) return -1; if(!read_u32(fd, &(header->size))) return -1; header->size = convert_size(header->size); return 0; }
/** * Reads a frame, stores data into the structure * * @param fd file descriptor * @param frame structure pointer * * @return -1 on error, 0 otherwise */ int tag_read_one_frame(int fd, id3v2_frame_t *frame) { u8 encoding; int i = 0; if(read_string(fd, frame->id, ID3V2_FRAME_ID_LENGTH, 0) == NULL) return -1; if(!read_u32(fd, &(frame->size))) return -1; if(!read_u16(fd, &(frame->flags))) return -1; if(frame->id[0] != 'T' || !strcmp(frame->id, "TXXX")) { lseek(fd, frame->size, SEEK_CUR); frame->text = NULL; return -1; } for(i = 0 ; i < ID3V2_FRAME_ID_LENGTH ; i++) { if(!isupper(frame->id[i]) && !isdigit(frame->id[i])) { lseek(fd, frame->size, SEEK_CUR); frame->text = NULL; return -1; } } if(!read_u8(fd, &(encoding))) return -1; frame->text = read_string(fd, NULL, frame->size - 1, (int) encoding); if(frame->text == NULL) return -1; return 0; }
int tag_read_id3_header(int fd, id3v2_header_t *header) { if(strcmp("ID3", read_string(fd, header->ID3, 3, 0)) != 0) { printf("titi1"); return -1; } if(!read_u16(fd, &(header->version))) { printf("titi2"); return -1; } // version valide if(header->version > 0x0300) { printf("titi3"); return -1; } if(!read_u8(fd, &(header->flags))) { printf("titi4"); return -1; } if(!read_u32(fd, &(header->size))) { printf("titi5"); return -1; } header->size = convert_size(header->size); return 0; }
void metrohash128crc_1(const uint8_t * key, uint64_t len, uint32_t seed, uint8_t * out) { static const uint64_t k0 = 0xC83A91E1; static const uint64_t k1 = 0x8648DBDB; static const uint64_t k2 = 0x7BDEC03B; static const uint64_t k3 = 0x2F5870A5; const uint8_t * ptr = reinterpret_cast<const uint8_t*>(key); const uint8_t * const end = ptr + len; uint64_t v[4]; v[0] = ((static_cast<uint64_t>(seed) - k0) * k3) + len; v[1] = ((static_cast<uint64_t>(seed) + k1) * k2) + len; if (len >= 32) { v[2] = ((static_cast<uint64_t>(seed) + k0) * k2) + len; v[3] = ((static_cast<uint64_t>(seed) - k1) * k3) + len; do { v[0] ^= _mm_crc32_u64(v[0], read_u64(ptr)); ptr += 8; v[1] ^= _mm_crc32_u64(v[1], read_u64(ptr)); ptr += 8; v[2] ^= _mm_crc32_u64(v[2], read_u64(ptr)); ptr += 8; v[3] ^= _mm_crc32_u64(v[3], read_u64(ptr)); ptr += 8; } while (ptr <= (end - 32)); v[2] ^= rotate_right(((v[0] + v[3]) * k0) + v[1], 34) * k1; v[3] ^= rotate_right(((v[1] + v[2]) * k1) + v[0], 37) * k0; v[0] ^= rotate_right(((v[0] + v[2]) * k0) + v[3], 34) * k1; v[1] ^= rotate_right(((v[1] + v[3]) * k1) + v[2], 37) * k0; } if ((end - ptr) >= 16) { v[0] += read_u64(ptr) * k2; ptr += 8; v[0] = rotate_right(v[0],34) * k3; v[1] += read_u64(ptr) * k2; ptr += 8; v[1] = rotate_right(v[1],34) * k3; v[0] ^= rotate_right((v[0] * k2) + v[1], 30) * k1; v[1] ^= rotate_right((v[1] * k3) + v[0], 30) * k0; } if ((end - ptr) >= 8) { v[0] += read_u64(ptr) * k2; ptr += 8; v[0] = rotate_right(v[0],36) * k3; v[0] ^= rotate_right((v[0] * k2) + v[1], 23) * k1; } if ((end - ptr) >= 4) { v[1] ^= _mm_crc32_u64(v[0], read_u32(ptr)); ptr += 4; v[1] ^= rotate_right((v[1] * k3) + v[0], 19) * k0; } if ((end - ptr) >= 2) { v[0] ^= _mm_crc32_u64(v[1], read_u16(ptr)); ptr += 2; v[0] ^= rotate_right((v[0] * k2) + v[1], 13) * k1; } if ((end - ptr) >= 1) { v[1] ^= _mm_crc32_u64(v[0], read_u8 (ptr)); v[1] ^= rotate_right((v[1] * k3) + v[0], 17) * k0; } v[0] += rotate_right((v[0] * k0) + v[1], 11); v[1] += rotate_right((v[1] * k1) + v[0], 26); v[0] += rotate_right((v[0] * k0) + v[1], 11); v[1] += rotate_right((v[1] * k1) + v[0], 26); memcpy(out, v, 16); }
void metrohash128crc_2(const uint8_t * key, uint64_t len, uint32_t seed, uint8_t * out) { static const uint64_t k0 = 0xEE783E2F; static const uint64_t k1 = 0xAD07C493; static const uint64_t k2 = 0x797A90BB; static const uint64_t k3 = 0x2E4B2E1B; const uint8_t * ptr = reinterpret_cast<const uint8_t*>(key); const uint8_t * const end = ptr + len; uint64_t v[4]; v[0] = ((static_cast<uint64_t>(seed) - k0) * k3) + len; v[1] = ((static_cast<uint64_t>(seed) + k1) * k2) + len; if (len >= 32) { v[2] = ((static_cast<uint64_t>(seed) + k0) * k2) + len; v[3] = ((static_cast<uint64_t>(seed) - k1) * k3) + len; do { v[0] ^= _mm_crc32_u64(v[0], read_u64(ptr)); ptr += 8; v[1] ^= _mm_crc32_u64(v[1], read_u64(ptr)); ptr += 8; v[2] ^= _mm_crc32_u64(v[2], read_u64(ptr)); ptr += 8; v[3] ^= _mm_crc32_u64(v[3], read_u64(ptr)); ptr += 8; } while (ptr <= (end - 32)); v[2] ^= rotate_right(((v[0] + v[3]) * k0) + v[1], 12) * k1; v[3] ^= rotate_right(((v[1] + v[2]) * k1) + v[0], 19) * k0; v[0] ^= rotate_right(((v[0] + v[2]) * k0) + v[3], 12) * k1; v[1] ^= rotate_right(((v[1] + v[3]) * k1) + v[2], 19) * k0; } if ((end - ptr) >= 16) { v[0] += read_u64(ptr) * k2; ptr += 8; v[0] = rotate_right(v[0],41) * k3; v[1] += read_u64(ptr) * k2; ptr += 8; v[1] = rotate_right(v[1],41) * k3; v[0] ^= rotate_right((v[0] * k2) + v[1], 10) * k1; v[1] ^= rotate_right((v[1] * k3) + v[0], 10) * k0; } if ((end - ptr) >= 8) { v[0] += read_u64(ptr) * k2; ptr += 8; v[0] = rotate_right(v[0],34) * k3; v[0] ^= rotate_right((v[0] * k2) + v[1], 22) * k1; } if ((end - ptr) >= 4) { v[1] ^= _mm_crc32_u64(v[0], read_u32(ptr)); ptr += 4; v[1] ^= rotate_right((v[1] * k3) + v[0], 14) * k0; } if ((end - ptr) >= 2) { v[0] ^= _mm_crc32_u64(v[1], read_u16(ptr)); ptr += 2; v[0] ^= rotate_right((v[0] * k2) + v[1], 15) * k1; } if ((end - ptr) >= 1) { v[1] ^= _mm_crc32_u64(v[0], read_u8 (ptr)); v[1] ^= rotate_right((v[1] * k3) + v[0], 18) * k0; } v[0] += rotate_right((v[0] * k0) + v[1], 15); v[1] += rotate_right((v[1] * k1) + v[0], 27); v[0] += rotate_right((v[0] * k0) + v[1], 15); v[1] += rotate_right((v[1] * k1) + v[0], 27); memcpy(out, v, 16); }
/* Check all the heap tags in a heap dump */ static int check_tags(unsigned char *pstart, int nbytes) { unsigned char *p; int nrecord; struct LookupTable *utab; UmapInfo umap; check_printf("\nCHECK TAGS: starting\n"); utab = table_initialize("temp utf8 map", 64, 64, 512, sizeof(UmapInfo)); /* Walk the tags, assumes UTF8 tags are defined before used */ p = pstart; nrecord = 0; while ( p < (pstart+nbytes) ) { unsigned tag; unsigned size; int nheap_records; int npos; char *label; HprofId id, nm, sg, so, gr, gn; int i, li, num_elements; HprofType ty; SerialNumber trace_serial_num; SerialNumber thread_serial_num; SerialNumber class_serial_num; unsigned flags; unsigned depth; float cutoff; unsigned temp; jint nblive; jint nilive; jlong tbytes; jlong tinsts; jint total_samples; jint trace_count; nrecord++; /*LINTED*/ npos = (int)(p - pstart); tag = read_u1(&p); (void)read_u4(&p); /* microsecs */ size = read_u4(&p); #define CASE_TAG(name) case name: label = #name; switch ( tag ) { CASE_TAG(HPROF_UTF8) CHECK_FOR_ERROR(size>=(int)sizeof(HprofId)); id = read_id(&p); check_printf("#%d@%d: %s, sz=%d, name_id=0x%x, \"", nrecord, npos, label, size, id); num_elements = size-(int)sizeof(HprofId); check_raw(p, num_elements); check_printf("\"\n"); /* Create entry in umap */ umap.str = HPROF_MALLOC(num_elements+1); (void)strncpy(umap.str, (char*)p, (size_t)num_elements); umap.str[num_elements] = 0; (void)table_create_entry(utab, &id, sizeof(id), &umap); p += num_elements; break; CASE_TAG(HPROF_LOAD_CLASS) CHECK_FOR_ERROR(size==2*4+2*(int)sizeof(HprofId)); class_serial_num = read_u4(&p); CHECK_CLASS_SERIAL_NO(class_serial_num); id = read_id(&p); trace_serial_num = read_u4(&p); CHECK_TRACE_SERIAL_NO(trace_serial_num); nm = read_id(&p); check_printf("#%d@%d: %s, sz=%d, class_serial_num=%u," " id=0x%x, trace_serial_num=%u, name_id=0x%x\n", nrecord, npos, label, size, class_serial_num, id, trace_serial_num, nm); break; CASE_TAG(HPROF_UNLOAD_CLASS) CHECK_FOR_ERROR(size==4); class_serial_num = read_u4(&p); CHECK_CLASS_SERIAL_NO(class_serial_num); check_printf("#%d@%d: %s, sz=%d, class_serial_num=%u\n", nrecord, npos, label, size, class_serial_num); break; CASE_TAG(HPROF_FRAME) CHECK_FOR_ERROR(size==2*4+4*(int)sizeof(HprofId)); id = read_id(&p); nm = read_id(&p); sg = read_id(&p); so = read_id(&p); class_serial_num = read_u4(&p); CHECK_CLASS_SERIAL_NO(class_serial_num); li = read_u4(&p); check_printf("#%d@%d: %s, sz=%d, ", nrecord, npos, label, size); check_print_utf8(utab, "id=", id); check_printf(" name_id=0x%x, sig_id=0x%x, source_id=0x%x," " class_serial_num=%u, lineno=%d\n", nm, sg, so, class_serial_num, li); break; CASE_TAG(HPROF_TRACE) CHECK_FOR_ERROR(size>=3*4); trace_serial_num = read_u4(&p); CHECK_TRACE_SERIAL_NO(trace_serial_num); thread_serial_num = read_u4(&p); /* Can be 0 */ num_elements = read_u4(&p); check_printf("#%d@%d: %s, sz=%d, trace_serial_num=%u," " thread_serial_num=%u, nelems=%d [", nrecord, npos, label, size, trace_serial_num, thread_serial_num, num_elements); for(i=0; i< num_elements; i++) { check_printf("0x%x,", read_id(&p)); } check_printf("]\n"); break; CASE_TAG(HPROF_ALLOC_SITES) CHECK_FOR_ERROR(size>=2+4*4+2*8); flags = read_u2(&p); temp = read_u4(&p); cutoff = *((float*)&temp); nblive = read_u4(&p); nilive = read_u4(&p); tbytes = read_u8(&p); tinsts = read_u8(&p); num_elements = read_u4(&p); check_printf("#%d@%d: %s, sz=%d, flags=0x%x, cutoff=%g," " nblive=%d, nilive=%d, tbytes=(%d,%d)," " tinsts=(%d,%d), num_elements=%d\n", nrecord, npos, label, size, flags, cutoff, nblive, nilive, jlong_high(tbytes), jlong_low(tbytes), jlong_high(tinsts), jlong_low(tinsts), num_elements); for(i=0; i< num_elements; i++) { ty = read_u1(&p); class_serial_num = read_u4(&p); CHECK_CLASS_SERIAL_NO(class_serial_num); trace_serial_num = read_u4(&p); CHECK_TRACE_SERIAL_NO(trace_serial_num); nblive = read_u4(&p); nilive = read_u4(&p); tbytes = read_u4(&p); tinsts = read_u4(&p); check_printf("\t %d: ty=%d, class_serial_num=%u," " trace_serial_num=%u, nblive=%d, nilive=%d," " tbytes=%d, tinsts=%d\n", i, ty, class_serial_num, trace_serial_num, nblive, nilive, (jint)tbytes, (jint)tinsts); } break; CASE_TAG(HPROF_HEAP_SUMMARY) CHECK_FOR_ERROR(size==2*4+2*8); nblive = read_u4(&p); nilive = read_u4(&p); tbytes = read_u8(&p); tinsts = read_u8(&p); check_printf("#%d@%d: %s, sz=%d," " nblive=%d, nilive=%d, tbytes=(%d,%d)," " tinsts=(%d,%d)\n", nrecord, npos, label, size, nblive, nilive, jlong_high(tbytes), jlong_low(tbytes), jlong_high(tinsts), jlong_low(tinsts)); break; CASE_TAG(HPROF_START_THREAD) CHECK_FOR_ERROR(size==2*4+4*(int)sizeof(HprofId)); thread_serial_num = read_u4(&p); CHECK_THREAD_SERIAL_NO(thread_serial_num); id = read_id(&p); trace_serial_num = read_u4(&p); CHECK_TRACE_SERIAL_NO(trace_serial_num); nm = read_id(&p); gr = read_id(&p); gn = read_id(&p); check_printf("#%d@%d: %s, sz=%d, thread_serial_num=%u," " id=0x%x, trace_serial_num=%u, ", nrecord, npos, label, size, thread_serial_num, id, trace_serial_num); check_print_utf8(utab, "nm=", id); check_printf(" trace_serial_num=%u, nm=0x%x," " gr=0x%x, gn=0x%x\n", trace_serial_num, nm, gr, gn); break; CASE_TAG(HPROF_END_THREAD) CHECK_FOR_ERROR(size==4); thread_serial_num = read_u4(&p); CHECK_THREAD_SERIAL_NO(thread_serial_num); check_printf("#%d@%d: %s, sz=%d, thread_serial_num=%u\n", nrecord, npos, label, size, thread_serial_num); break; CASE_TAG(HPROF_HEAP_DUMP) check_printf("#%d@%d: BEGIN: %s, sz=%d\n", nrecord, npos, label, size); nheap_records = check_heap_tags(utab, p, size); check_printf("#%d@%d: END: %s, sz=%d, nheap_recs=%d\n", nrecord, npos, label, size, nheap_records); p += size; break; CASE_TAG(HPROF_HEAP_DUMP_SEGMENT) /* 1.0.2 */ check_printf("#%d@%d: BEGIN SEGMENT: %s, sz=%d\n", nrecord, npos, label, size); nheap_records = check_heap_tags(utab, p, size); check_printf("#%d@%d: END SEGMENT: %s, sz=%d, nheap_recs=%d\n", nrecord, npos, label, size, nheap_records); p += size; break; CASE_TAG(HPROF_HEAP_DUMP_END) /* 1.0.2 */ check_printf("#%d@%d: SEGMENT END: %s, sz=%d\n", nrecord, npos, label, size); break; CASE_TAG(HPROF_CPU_SAMPLES) CHECK_FOR_ERROR(size>=2*4); total_samples = read_u4(&p); trace_count = read_u4(&p); check_printf("#%d@%d: %s, sz=%d, total_samples=%d," " trace_count=%d\n", nrecord, npos, label, size, total_samples, trace_count); for(i=0; i< trace_count; i++) { num_elements = read_u4(&p); trace_serial_num = read_u4(&p); CHECK_TRACE_SERIAL_NO(trace_serial_num); check_printf("\t %d: samples=%d, trace_serial_num=%u\n", trace_serial_num, num_elements); } break; CASE_TAG(HPROF_CONTROL_SETTINGS) CHECK_FOR_ERROR(size==4+2); flags = read_u4(&p); depth = read_u2(&p); check_printf("#%d@%d: %s, sz=%d, flags=0x%x, depth=%d\n", nrecord, npos, label, size, flags, depth); break; default: label = "UNKNOWN"; check_printf("#%d@%d: %s, sz=%d\n", nrecord, npos, label, size); HPROF_ERROR(JNI_TRUE, "unknown record type"); p += size; break; } CHECK_FOR_ERROR(p<=(pstart+nbytes)); } check_flush(); CHECK_FOR_ERROR(p==(pstart+nbytes)); table_cleanup(utab, &utab_cleanup, NULL); return nrecord; }
void metrohash64crc_1(const uint8_t * key, uint64_t len, uint32_t seed, uint8_t * out) { static const uint64_t k0 = 0xC83A91E1; static const uint64_t k1 = 0x8648DBDB; static const uint64_t k2 = 0x7BDEC03B; static const uint64_t k3 = 0x2F5870A5; const uint8_t * ptr = reinterpret_cast<const uint8_t*>(key); const uint8_t * const end = ptr + len; uint64_t hash = ((static_cast<uint64_t>(seed) + k2) * k0) + len; if (len >= 32) { uint64_t v[4]; v[0] = hash; v[1] = hash; v[2] = hash; v[3] = hash; do { v[0] ^= _mm_crc32_u64(v[0], read_u64(ptr)); ptr += 8; v[1] ^= _mm_crc32_u64(v[1], read_u64(ptr)); ptr += 8; v[2] ^= _mm_crc32_u64(v[2], read_u64(ptr)); ptr += 8; v[3] ^= _mm_crc32_u64(v[3], read_u64(ptr)); ptr += 8; } while (ptr <= (end - 32)); v[2] ^= rotate_right(((v[0] + v[3]) * k0) + v[1], 33) * k1; v[3] ^= rotate_right(((v[1] + v[2]) * k1) + v[0], 33) * k0; v[0] ^= rotate_right(((v[0] + v[2]) * k0) + v[3], 33) * k1; v[1] ^= rotate_right(((v[1] + v[3]) * k1) + v[2], 33) * k0; hash += v[0] ^ v[1]; } if ((end - ptr) >= 16) { uint64_t v0 = hash + (read_u64(ptr) * k0); ptr += 8; v0 = rotate_right(v0,33) * k1; uint64_t v1 = hash + (read_u64(ptr) * k1); ptr += 8; v1 = rotate_right(v1,33) * k2; v0 ^= rotate_right(v0 * k0, 35) + v1; v1 ^= rotate_right(v1 * k3, 35) + v0; hash += v1; } if ((end - ptr) >= 8) { hash += read_u64(ptr) * k3; ptr += 8; hash ^= rotate_right(hash, 33) * k1; } if ((end - ptr) >= 4) { hash ^= _mm_crc32_u64(hash, read_u32(ptr)); ptr += 4; hash ^= rotate_right(hash, 15) * k1; } if ((end - ptr) >= 2) { hash ^= _mm_crc32_u64(hash, read_u16(ptr)); ptr += 2; hash ^= rotate_right(hash, 13) * k1; } if ((end - ptr) >= 1) { hash ^= _mm_crc32_u64(hash, read_u8(ptr)); hash ^= rotate_right(hash, 25) * k1; } hash ^= rotate_right(hash, 33); hash *= k0; hash ^= rotate_right(hash, 33); memcpy(out, &hash, 8); }
void metrohash128_2(const uint8_t * key, uint64_t len, uint32_t seed, uint8_t * out) { static const uint64_t k0 = 0xD6D018F5; static const uint64_t k1 = 0xA2AA033B; static const uint64_t k2 = 0x62992FC1; static const uint64_t k3 = 0x30BC5B29; const uint8_t * ptr = reinterpret_cast<const uint8_t*>(key); const uint8_t * const end = ptr + len; uint64_t v[4]; v[0] = ((static_cast<uint64_t>(seed) - k0) * k3) + len; v[1] = ((static_cast<uint64_t>(seed) + k1) * k2) + len; if (len >= 32) { v[2] = ((static_cast<uint64_t>(seed) + k0) * k2) + len; v[3] = ((static_cast<uint64_t>(seed) - k1) * k3) + len; do { v[0] += read_u64(ptr) * k0; ptr += 8; v[0] = rotate_right(v[0],29) + v[2]; v[1] += read_u64(ptr) * k1; ptr += 8; v[1] = rotate_right(v[1],29) + v[3]; v[2] += read_u64(ptr) * k2; ptr += 8; v[2] = rotate_right(v[2],29) + v[0]; v[3] += read_u64(ptr) * k3; ptr += 8; v[3] = rotate_right(v[3],29) + v[1]; } while (ptr <= (end - 32)); v[2] ^= rotate_right(((v[0] + v[3]) * k0) + v[1], 33) * k1; v[3] ^= rotate_right(((v[1] + v[2]) * k1) + v[0], 33) * k0; v[0] ^= rotate_right(((v[0] + v[2]) * k0) + v[3], 33) * k1; v[1] ^= rotate_right(((v[1] + v[3]) * k1) + v[2], 33) * k0; } if ((end - ptr) >= 16) { v[0] += read_u64(ptr) * k2; ptr += 8; v[0] = rotate_right(v[0],29) * k3; v[1] += read_u64(ptr) * k2; ptr += 8; v[1] = rotate_right(v[1],29) * k3; v[0] ^= rotate_right((v[0] * k2) + v[1], 29) * k1; v[1] ^= rotate_right((v[1] * k3) + v[0], 29) * k0; } if ((end - ptr) >= 8) { v[0] += read_u64(ptr) * k2; ptr += 8; v[0] = rotate_right(v[0],29) * k3; v[0] ^= rotate_right((v[0] * k2) + v[1], 29) * k1; } if ((end - ptr) >= 4) { v[1] += read_u32(ptr) * k2; ptr += 4; v[1] = rotate_right(v[1],29) * k3; v[1] ^= rotate_right((v[1] * k3) + v[0], 25) * k0; } if ((end - ptr) >= 2) { v[0] += read_u16(ptr) * k2; ptr += 2; v[0] = rotate_right(v[0],29) * k3; v[0] ^= rotate_right((v[0] * k2) + v[1], 30) * k1; } if ((end - ptr) >= 1) { v[1] += read_u8 (ptr) * k2; v[1] = rotate_right(v[1],29) * k3; v[1] ^= rotate_right((v[1] * k3) + v[0], 18) * k0; } v[0] += rotate_right((v[0] * k0) + v[1], 33); v[1] += rotate_right((v[1] * k1) + v[0], 33); v[0] += rotate_right((v[0] * k2) + v[1], 33); v[1] += rotate_right((v[1] * k3) + v[0], 33); // do any endian conversion here memcpy(out, v, 16); }
void MetroHash128::Hash(const uint8_t * buffer, const uint64_t length, uint8_t * const hash, const uint64_t seed) { const uint8_t * ptr = reinterpret_cast<const uint8_t*>(buffer); const uint8_t * const end = ptr + length; uint64_t v[4]; v[0] = (static_cast<uint64_t>(seed) - k0) * k3; v[1] = (static_cast<uint64_t>(seed) + k1) * k2; if (length >= 32) { v[2] = (static_cast<uint64_t>(seed) + k0) * k2; v[3] = (static_cast<uint64_t>(seed) - k1) * k3; do { v[0] += read_u64(ptr) * k0; ptr += 8; v[0] = rotate_right(v[0],29) + v[2]; v[1] += read_u64(ptr) * k1; ptr += 8; v[1] = rotate_right(v[1],29) + v[3]; v[2] += read_u64(ptr) * k2; ptr += 8; v[2] = rotate_right(v[2],29) + v[0]; v[3] += read_u64(ptr) * k3; ptr += 8; v[3] = rotate_right(v[3],29) + v[1]; } while (ptr <= (end - 32)); v[2] ^= rotate_right(((v[0] + v[3]) * k0) + v[1], 21) * k1; v[3] ^= rotate_right(((v[1] + v[2]) * k1) + v[0], 21) * k0; v[0] ^= rotate_right(((v[0] + v[2]) * k0) + v[3], 21) * k1; v[1] ^= rotate_right(((v[1] + v[3]) * k1) + v[2], 21) * k0; } if ((end - ptr) >= 16) { v[0] += read_u64(ptr) * k2; ptr += 8; v[0] = rotate_right(v[0],33) * k3; v[1] += read_u64(ptr) * k2; ptr += 8; v[1] = rotate_right(v[1],33) * k3; v[0] ^= rotate_right((v[0] * k2) + v[1], 45) * k1; v[1] ^= rotate_right((v[1] * k3) + v[0], 45) * k0; } if ((end - ptr) >= 8) { v[0] += read_u64(ptr) * k2; ptr += 8; v[0] = rotate_right(v[0],33) * k3; v[0] ^= rotate_right((v[0] * k2) + v[1], 27) * k1; } if ((end - ptr) >= 4) { v[1] += read_u32(ptr) * k2; ptr += 4; v[1] = rotate_right(v[1],33) * k3; v[1] ^= rotate_right((v[1] * k3) + v[0], 46) * k0; } if ((end - ptr) >= 2) { v[0] += read_u16(ptr) * k2; ptr += 2; v[0] = rotate_right(v[0],33) * k3; v[0] ^= rotate_right((v[0] * k2) + v[1], 22) * k1; } if ((end - ptr) >= 1) { v[1] += read_u8 (ptr) * k2; v[1] = rotate_right(v[1],33) * k3; v[1] ^= rotate_right((v[1] * k3) + v[0], 58) * k0; } v[0] += rotate_right((v[0] * k0) + v[1], 13); v[1] += rotate_right((v[1] * k1) + v[0], 37); v[0] += rotate_right((v[0] * k2) + v[1], 13); v[1] += rotate_right((v[1] * k3) + v[0], 37); // do any endian conversion here memcpy(hash, v, 16); }
// Parse the user data for captions. The udtype variable denotes // to which type of data it belongs: // 0 .. sequence header // 1 .. GOP header // 2 .. picture header // Return TRUE if the data parsing finished, FALSE otherwise. // estream->pos is advanced. Data is only processed if ustream->error // is FALSE, parsing can set ustream->error to TRUE. int user_data(struct lib_cc_decode *ctx, struct bitstream *ustream, int udtype, struct cc_subtitle *sub) { dbg_print(CCX_DMT_VERBOSE, "user_data(%d)\n", udtype); // Shall not happen if (ustream->error || ustream->bitsleft <= 0) { // ustream->error=1; return 0; // Actually discarded on call. // CFS: Seen in a Wobble edited file. // fatal(CCX_COMMON_EXIT_BUG_BUG, "user_data: Impossible!"); } // Do something ctx->stat_numuserheaders++; //header+=4; unsigned char *ud_header = next_bytes(ustream, 4); if (ustream->error || ustream->bitsleft <= 0) { return 0; // Actually discarded on call. // CFS: Seen in Stick_VHS.mpg. // fatal(CCX_COMMON_EXIT_BUG_BUG, "user_data: Impossible!"); } // DVD CC header, see // <http://www.theneitherworld.com/mcpoodle/SCC_TOOLS/DOCS/SCC_FORMAT.HTML> if ( !memcmp(ud_header,"\x43\x43", 2 ) ) { ctx->stat_dvdccheaders++; // Probably unneeded, but keep looking for extra caption blocks int maybeextracb = 1; read_bytes(ustream, 4); // "43 43 01 F8" unsigned char pattern_flag = (unsigned char) read_bits(ustream,1); read_bits(ustream,1); int capcount=(int) read_bits(ustream,5); int truncate_flag = (int) read_bits(ustream,1); // truncate_flag - one CB extra int field1packet = 0; // expect Field 1 first if (pattern_flag == 0x00) field1packet=1; // expect Field 1 second dbg_print(CCX_DMT_VERBOSE, "Reading %d%s DVD CC segments\n", capcount, (truncate_flag?"+1":"")); capcount += truncate_flag; // This data comes before the first frame header, so // in order to get the correct timing we need to set the // current time to one frame after the maximum time of the // last GOP. Only useful when there are frames before // the GOP. if (ctx->timing->fts_max > 0) ctx->timing->fts_now = ctx->timing->fts_max + (LLONG) (1000.0/current_fps); int rcbcount = 0; for (int i=0; i<capcount; i++) { for (int j=0;j<2;j++) { unsigned char data[3]; data[0]=read_u8(ustream); data[1]=read_u8(ustream); data[2]=read_u8(ustream); // Obey the truncate flag. if ( truncate_flag && i == capcount-1 && j == 1 ) { maybeextracb = 0; break; } /* Field 1 and 2 data can be in either order, with marker bytes of \xff and \xfe Since markers can be repeated, use pattern as well */ if ((data[0]&0xFE) == 0xFE) // Check if valid { if (data[0]==0xff && j==field1packet) data[0]=0x04; // Field 1 else data[0]=0x05; // Field 2 do_cb(ctx, data, sub); rcbcount++; } else { dbg_print(CCX_DMT_VERBOSE, "Illegal caption segment - stop here.\n"); maybeextracb = 0; break; } } } // Theoretically this should not happen, oh well ... // Deal with extra closed captions some DVD have. int ecbcount = 0; while ( maybeextracb && (next_u8(ustream)&0xFE) == 0xFE ) { for (int j=0;j<2;j++) { unsigned char data[3]; data[0]=read_u8(ustream); data[1]=read_u8(ustream); data[2]=read_u8(ustream); /* Field 1 and 2 data can be in either order, with marker bytes of \xff and \xfe Since markers can be repeated, use pattern as well */ if ((data[0]&0xFE) == 0xFE) // Check if valid { if (data[0]==0xff && j==field1packet) data[0]=0x04; // Field 1 else data[0]=0x05; // Field 2 do_cb(ctx, data, sub); ecbcount++; } else { dbg_print(CCX_DMT_VERBOSE, "Illegal (extra) caption segment - stop here.\n"); maybeextracb = 0; break; } } } dbg_print(CCX_DMT_VERBOSE, "Read %d/%d DVD CC blocks\n", rcbcount, ecbcount); } // SCTE 20 user data else if (!ctx->noscte20 && ud_header[0] == 0x03) { if ((ud_header[1]&0x7F) == 0x01) { unsigned char cc_data[3*31+1]; // Maximum cc_count is 31 ctx->stat_scte20ccheaders++; read_bytes(ustream, 2); // "03 01" unsigned cc_count = (unsigned int) read_bits(ustream,5); dbg_print(CCX_DMT_VERBOSE, "Reading %d SCTE 20 CC blocks\n", cc_count); unsigned field_number; unsigned cc_data1; unsigned cc_data2; for (unsigned j=0;j<cc_count;j++) { skip_bits(ustream,2); // priority - unused field_number = (unsigned int) read_bits(ustream,2); skip_bits(ustream,5); // line_offset - unused cc_data1 = (unsigned int) read_bits(ustream,8); cc_data2 = (unsigned int) read_bits(ustream,8); read_bits(ustream,1); // TODO: Add syntax check */ if (ustream->bitsleft < 0) fatal(CCX_COMMON_EXIT_BUG_BUG, "In user_data: ustream->bitsleft < 0. Cannot continue."); // Field_number is either // 0 .. forbidden // 1 .. field 1 (odd) // 2 .. field 2 (even) // 3 .. repeated, from repeat_first_field, effectively field 1 if (field_number < 1) { // 0 is invalid cc_data[j*3]=0x00; // Set to invalid cc_data[j*3+1]=0x00; cc_data[j*3+2]=0x00; } else { // Treat field_number 3 as 1 field_number = (field_number - 1) & 0x01; // top_field_first also affects to which field the caption // belongs. if(!ctx->top_field_first) field_number ^= 0x01; cc_data[j*3]=0x04|(field_number); cc_data[j*3+1]=reverse8(cc_data1); cc_data[j*3+2]=reverse8(cc_data2); } } cc_data[cc_count*3]=0xFF; store_hdcc(ctx, cc_data, cc_count, ctx->timing->current_tref, ctx->timing->fts_now, sub); dbg_print(CCX_DMT_VERBOSE, "Reading SCTE 20 CC blocks - done\n"); } // reserved - unspecified } // ReplayTV 4000/5000 caption header - parsing information // derived from CCExtract.bdl else if ( (ud_header[0] == 0xbb //ReplayTV 4000 || ud_header[0] == 0x99) //ReplayTV 5000 && ud_header[1] == 0x02 ) { unsigned char data[3]; if (ud_header[0]==0xbb) ctx->stat_replay4000headers++; else ctx->stat_replay5000headers++; read_bytes(ustream, 2); // "BB 02" or "99 02" data[0]=0x05; // Field 2 data[1]=read_u8(ustream); data[2]=read_u8(ustream); do_cb(ctx, data, sub); read_bytes(ustream, 2); // Skip "CC 02" for R4000 or "AA 02" for R5000 data[0]=0x04; // Field 1 data[1]=read_u8(ustream); data[2]=read_u8(ustream); do_cb(ctx, data, sub); } // HDTV - see A/53 Part 4 (Video) else if ( !memcmp(ud_header,"\x47\x41\x39\x34", 4 ) ) { ctx->stat_hdtv++; read_bytes(ustream, 4); // "47 41 39 34" unsigned char type_code = read_u8(ustream); if (type_code==0x03) // CC data. { skip_bits(ustream,1); // reserved unsigned char process_cc_data = (unsigned char) read_bits(ustream,1); skip_bits(ustream,1); // additional_data - unused unsigned char cc_count = (unsigned char) read_bits(ustream,5); read_bytes(ustream, 1); // "FF" if (process_cc_data) { dbg_print(CCX_DMT_VERBOSE, "Reading %d HDTV CC blocks\n", cc_count); int proceed = 1; unsigned char *cc_data = read_bytes(ustream, cc_count*3); if (ustream->bitsleft < 0) fatal(CCX_COMMON_EXIT_BUG_BUG, "In user_data: ustream->bitsleft < 0. Cannot continue.\n"); // Check for proper marker - This read makes sure that // cc_count*3+1 bytes are read and available in cc_data. if (read_u8(ustream)!=0xFF) proceed=0; if (!proceed) { dbg_print(CCX_DMT_VERBOSE, "\rThe following payload is not properly terminated.\n"); dump (CCX_DMT_VERBOSE, cc_data, cc_count*3+1, 0, 0); } dbg_print(CCX_DMT_VERBOSE, "Reading %d HD CC blocks\n", cc_count); // B-frames might be (temporal) before or after the anchor // frame they belong to. Store the buffer until the next anchor // frame occurs. The buffer will be flushed (sorted) in the // picture header (or GOP) section when the next anchor occurs. // Please note we store the current value of the global // fts_now variable (and not get_fts()) as we are going to // re-create the timeline in process_hdcc() (Slightly ugly). store_hdcc(ctx, cc_data, cc_count, ctx->timing->current_tref, ctx->timing->fts_now, sub); dbg_print(CCX_DMT_VERBOSE, "Reading HDTV blocks - done\n"); } } // reserved - additional_cc_data } // DVB closed caption header for Dish Network (Field 1 only) */ else if ( !memcmp(ud_header,"\x05\x02", 2 ) ) { // Like HDTV (above) Dish Network captions can be stored at each // frame, but maximal two caption blocks per frame and only one // field is stored. // To process this with the HDTV framework we create a "HDTV" caption // format compatible array. Two times 3 bytes plus one for the 0xFF // marker at the end. Pre-init to field 1 and set the 0xFF marker. static unsigned char dishdata[7] = {0x04, 0, 0, 0x04, 0, 0, 0xFF}; int cc_count; dbg_print(CCX_DMT_VERBOSE, "Reading Dish Network user data\n"); ctx->stat_dishheaders++; read_bytes(ustream, 2); // "05 02" // The next bytes are like this: // header[2] : ID: 0x04 (MPEG?), 0x03 (H264?) // header[3-4]: Two byte counter (counting (sub-)GOPs?) // header[5-6]: Two bytes, maybe checksum? // header[7]: Pattern type // on B-frame: 0x02, 0x04 // on I-/P-frame: 0x05 unsigned char id = read_u8(ustream); unsigned dishcount = read_u16(ustream); unsigned something = read_u16(ustream); unsigned char type = read_u8(ustream); dbg_print(CCX_DMT_PARSE, "DN ID: %02X Count: %5u Unknown: %04X Pattern: %X", id, dishcount, something, type); unsigned char hi; // The following block needs 4 to 6 bytes starting from the // current position unsigned char *dcd = ustream->pos; // dish caption data switch (type) { case 0x02: // Two byte caption - always on B-frame // The following 4 bytes are: // 0 : 0x09 // 1-2: caption block // 3 : REPEAT - 02: two bytes // - 04: four bytes (repeat first two) dbg_print(CCX_DMT_PARSE, "\n02 %02X %02X:%02X - R:%02X :", dcd[0], dcd[1], dcd[2], dcd[3]); cc_count = 1; dishdata[1]=dcd[1]; dishdata[2]=dcd[2]; dbg_print(CCX_DMT_PARSE, "%s", debug_608_to_ASC( dishdata, 0) ); type=dcd[3]; // repeater (0x02 or 0x04) hi = dishdata[1] & 0x7f; // Get only the 7 low bits if (type==0x04 && hi<32) // repeat (only for non-character pairs) { cc_count = 2; dishdata[3]=0x04; // Field 1 dishdata[4]=dishdata[1]; dishdata[5]=dishdata[2]; dbg_print(CCX_DMT_PARSE, "%s:\n", debug_608_to_ASC( dishdata+3, 0) ); } else { dbg_print(CCX_DMT_PARSE, ":\n"); } dishdata[cc_count*3] = 0xFF; // Set end marker store_hdcc(ctx, dishdata, cc_count, ctx->timing->current_tref, ctx->timing->fts_now, sub); // Ignore 3 (0x0A, followed by two unknown) bytes. break; case 0x04: // Four byte caption - always on B-frame // The following 5 bytes are: // 0 : 0x09 // 1-2: caption block // 3-4: caption block dbg_print(CCX_DMT_PARSE, "\n04 %02X %02X:%02X:%02X:%02X :", dcd[0], dcd[1], dcd[2], dcd[3], dcd[4]); cc_count = 2; dishdata[1]=dcd[1]; dishdata[2]=dcd[2]; dishdata[3]=0x04; // Field 1 dishdata[4]=dcd[3]; dishdata[5]=dcd[4]; dishdata[6] = 0xFF; // Set end marker dbg_print(CCX_DMT_PARSE, "%s", debug_608_to_ASC( dishdata, 0) ); dbg_print(CCX_DMT_PARSE, "%s:\n", debug_608_to_ASC( dishdata+3, 0) ); store_hdcc(ctx, dishdata, cc_count, ctx->timing->current_tref, ctx->timing->fts_now, sub); // Ignore 4 (0x020A, followed by two unknown) bytes. break; case 0x05: // Buffered caption - always on I-/P-frame // The following six bytes are: // 0 : 0x04 // - the following are from previous 0x05 caption header - // 1 : prev dcd[2] // 2-3: prev dcd[3-4] // 4-5: prev dcd[5-6] dbg_print(CCX_DMT_PARSE, " - %02X pch: %02X %5u %02X:%02X\n", dcd[0], dcd[1], (unsigned)dcd[2]*256+dcd[3], dcd[4], dcd[5]); dcd+=6; // Skip these 6 bytes // Now one of the "regular" 0x02 or 0x04 captions follows dbg_print(CCX_DMT_PARSE, "%02X %02X %02X:%02X", dcd[0], dcd[1], dcd[2], dcd[3]); type=dcd[0]; // Number of caption bytes (0x02 or 0x04) cc_count = 1; dishdata[1]=dcd[2]; dishdata[2]=dcd[3]; dcd+=4; // Skip the first 4 bytes. if (type==0x02) { type=dcd[0]; // repeater (0x02 or 0x04) dcd++; // Skip the repeater byte. dbg_print(CCX_DMT_PARSE, " - R:%02X :%s", type, debug_608_to_ASC( dishdata, 0) ); hi = dishdata[1] & 0x7f; // Get only the 7 low bits if (type==0x04 && hi<32) { cc_count = 2; dishdata[3]=0x04; // Field 1 dishdata[4]=dishdata[1]; dishdata[5]=dishdata[2]; dbg_print(CCX_DMT_PARSE, "%s:\n", debug_608_to_ASC( dishdata+3, 0) ); } else { dbg_print(CCX_DMT_PARSE, ":\n"); } dishdata[cc_count*3] = 0xFF; // Set end marker } else { dbg_print(CCX_DMT_PARSE, ":%02X:%02X ", dcd[0], dcd[1]); cc_count = 2; dishdata[3]=0x04; // Field 1 dishdata[4]=dcd[0]; dishdata[5]=dcd[1]; dishdata[6] = 0xFF; // Set end marker dbg_print(CCX_DMT_PARSE, ":%s", debug_608_to_ASC( dishdata, 0) ); dbg_print(CCX_DMT_PARSE, "%s:\n", debug_608_to_ASC( dishdata+3, 0) ); } store_hdcc(ctx, dishdata, cc_count, ctx->timing->current_tref, ctx->timing->fts_now, sub); // Ignore 3 (0x0A, followed by 2 unknown) bytes. break; default: // printf ("Unknown?\n"); break; } // switch dbg_print(CCX_DMT_VERBOSE, "Reading Dish Network user data - done\n"); } // CEA 608 / aka "Divicom standard", see: // http://www.pixeltools.com/tech_tip_closed_captioning.html else if ( !memcmp(ud_header,"\x02\x09", 2 ) ) { // Either a documentation or more examples are needed. ctx->stat_divicom++; unsigned char data[3]; read_bytes(ustream, 2); // "02 09" read_bytes(ustream, 2); // "80 80" ??? read_bytes(ustream, 2); // "02 0A" ??? data[0]=0x04; // Field 1 data[1]=read_u8(ustream); data[2]=read_u8(ustream); do_cb(ctx, data, sub); // This is probably incomplete! } // GXF vbi OEM code else if ( !memcmp(ud_header,"\x73\x52\x21\x06", 4 ) ) { int udatalen = ustream->end - ustream->pos; uint16_t line_nb; uint8_t line_type; uint8_t field = 1; read_bytes(ustream, 4); //skip header code read_bytes(ustream, 2); //skip data length line_nb = read_bits(ustream, 16); line_type = read_u8(ustream); field = (line_type & 0x03); if(field == 0) mprint("MPEG:VBI: Invalid field\n"); line_type = line_type >> 2; if(line_type != 1) mprint("MPEG:VBI: only support Luma line\n"); if (udatalen < 720) mprint("MPEG:VBI: Minimum 720 bytes in luma line required\n"); decode_vbi(ctx, field, ustream->pos, 720, sub); dbg_print(CCX_DMT_VERBOSE, "GXF (vbi line %d) user data:\n", line_nb); }
void process(NIC* ni) { static uint32_t myip = 0xc0a86402; // 192.168.100.2 Packet* packet = nic_input(ni); if(!packet) return; Ether* ether = (Ether*)(packet->buffer + packet->start); if(endian16(ether->type) == ETHER_TYPE_ARP) { // ARP response ARP* arp = (ARP*)ether->payload; if(endian16(arp->operation) == 1 && endian32(arp->tpa) == myip) { ether->dmac = ether->smac; ether->smac = endian48(ni->mac); arp->operation = endian16(2); arp->tha = arp->sha; arp->tpa = arp->spa; arp->sha = ether->smac; arp->spa = endian32(myip); nic_output(ni, packet); packet = NULL; } } else if(endian16(ether->type) == ETHER_TYPE_IPv4) { IP* ip = (IP*)ether->payload; if(ip->protocol == IP_PROTOCOL_ICMP && endian32(ip->destination) == myip) { // Echo reply ICMP* icmp = (ICMP*)ip->body; icmp->type = 0; icmp->checksum = 0; icmp->checksum = endian16(checksum(icmp, packet->end - packet->start - ETHER_LEN - IP_LEN)); ip->destination = ip->source; ip->source = endian32(myip); ip->ttl = endian8(64); ip->checksum = 0; ip->checksum = endian16(checksum(ip, ip->ihl * 4)); ether->dmac = ether->smac; ether->smac = endian48(ni->mac); nic_output(ni, packet); packet = NULL; } else if(ip->protocol == IP_PROTOCOL_UDP) { UDP* udp = (UDP*)ip->body; if(endian16(udp->destination) == 9000) { reply_count = 2; // Control packet uint32_t idx = 0; seq = read_u16(udp->body, &idx); user_mac = endian48(ether->smac); user_ip = endian32(ip->source); user_port = endian16(udp->source); uint8_t msg = read_u8(udp->body, &idx); switch(msg) { case 1: // MSG_CREATE { idx++; // read ctype uint32_t clen = read_u32(udp->body, &idx); char collection[clen + 1]; collection[clen] = '\0'; memcpy(collection, udp->body + idx, clen); idx += clen; uint64_t id = newID(collection); memmove(udp->body + idx + 9, udp->body + idx, endian16(udp->length) - 8 - idx); packet->end += 9; udp->length = endian16(endian16(udp->length) + 9); ip->length = endian16(endian16(ip->length) + 9); write_u8(udp->body, 4, &idx); write_u64(udp->body, id, &idx); } break; case 2: // MSG_READ reply_count = 1; break; case 3: // MSG_RETRIEVE break; case 4: // MSG_UPDATE break; case 5: // MSG_DELETE break; case 6: // MSG_HELLO reply_count = 1; break; } udp->source = endian16(9999); udp->destination = endian16(9001); udp->checksum = 0; ip->destination = ip->source; ip->source = endian32(myip); ip->ttl = endian8(ip->ttl) - 1; ip->checksum = 0; ip->checksum = endian16(checksum(ip, ip->ihl * 4)); ether->dmac = ether->smac; ether->smac = endian48(ni->mac); nic_output_dup(ni, packet); udp->destination = endian16(9002); ip->checksum = 0; ip->checksum = endian16(checksum(ip, ip->ihl * 4)); nic_output_dup(ni, packet); udp->destination = endian16(9003); ip->checksum = 0; ip->checksum = endian16(checksum(ip, ip->ihl * 4)); nic_output(ni, packet); packet = NULL; } else if(endian16(udp->destination) == 9999) { uint32_t idx = 0; uint16_t seq2 = read_u16(udp->body, &idx); if(seq == seq2 && --reply_count == 0) { udp->checksum = 0; udp->destination = endian16(user_port); udp->source = endian16(9000); ip->destination = endian32(user_ip); ip->source = endian32(myip); ip->ttl = endian8(64); ip->checksum = 0; ip->checksum = endian16(checksum(ip, ip->ihl * 4)); ether->dmac = endian48(user_mac); ether->smac = endian48(ni->mac); nic_output(ni, packet); packet = NULL; } } } } if(packet) nic_free(packet); }
bool db_dwarf_line_at_pc(const char *linetab, size_t linetabsize, uintptr_t pc, const char **outdirname, const char **outbasename, int *outline) { struct dwbuf table = { .buf = linetab, .len = linetabsize }; /* * For simplicity, we simply brute force search through the entire * line table each time. */ uint32_t unitsize; struct dwbuf unit; next: /* Line tables are a sequence of compilation unit entries. */ if (!read_u32(&table, &unitsize) || unitsize >= 0xfffffff0 || !read_buf(&table, &unit, unitsize)) return (false); uint16_t version; uint32_t header_size; if (!read_u16(&unit, &version) || version > 2 || !read_u32(&unit, &header_size)) goto next; struct dwbuf headerstart = unit; uint8_t min_insn_length, default_is_stmt, line_range, opcode_base; int8_t line_base; if (!read_u8(&unit, &min_insn_length) || !read_u8(&unit, &default_is_stmt) || !read_s8(&unit, &line_base) || !read_u8(&unit, &line_range) || !read_u8(&unit, &opcode_base)) goto next; /* * Directory and file names are next in the header, but for now we * skip directly to the line number program. */ struct dwbuf names = unit; unit = headerstart; if (!skip_bytes(&unit, header_size)) return (false); /* VM registers. */ uint64_t address = 0, file = 1, line = 1, column = 0; uint8_t is_stmt = default_is_stmt; bool basic_block = false, end_sequence = false; bool prologue_end = false, epilogue_begin = false; /* Last line table entry emitted, if any. */ bool have_last = false; uint64_t last_line = 0, last_file = 0; /* Time to run the line program. */ uint8_t opcode; while (read_u8(&unit, &opcode)) { bool emit = false, reset_basic_block = false; if (opcode >= opcode_base) { /* "Special" opcodes. */ uint8_t diff = opcode - opcode_base; address += diff / line_range; line += line_base + diff % line_range; emit = true; } else if (opcode == 0) { /* "Extended" opcodes. */ uint64_t extsize; struct dwbuf extra; if (!read_uleb128(&unit, &extsize) || !read_buf(&unit, &extra, extsize) || !read_u8(&extra, &opcode)) goto next; switch (opcode) { case DW_LNE_end_sequence: emit = true; end_sequence = true; break; case DW_LNE_set_address: switch (extra.len) { case 4: { uint32_t address32; if (!read_u32(&extra, &address32)) goto next; address = address32; break; } case 8: if (!read_u64(&extra, &address)) goto next; break; default: DWARN("unexpected address length: %zu", extra.len); goto next; } break; case DW_LNE_define_file: /* XXX: hope this isn't needed */ default: DWARN("unknown extended opcode: %d", opcode); goto next; } } else { /* "Standard" opcodes. */ switch (opcode) { case DW_LNS_copy: emit = true; reset_basic_block = true; break; case DW_LNS_advance_pc: { uint64_t delta; if (!read_uleb128(&unit, &delta)) goto next; address += delta * min_insn_length; break; } case DW_LNS_advance_line: { int64_t delta; if (!read_sleb128(&unit, &delta)) goto next; line += delta; break; } case DW_LNS_set_file: if (!read_uleb128(&unit, &file)) goto next; break; case DW_LNS_set_column: if (!read_uleb128(&unit, &column)) goto next; break; case DW_LNS_negate_stmt: is_stmt = !is_stmt; break; case DW_LNS_set_basic_block: basic_block = true; break; case DW_LNS_const_add_pc: address += (255 - opcode_base) / line_range; break; case DW_LNS_set_prologue_end: prologue_end = true; break; case DW_LNS_set_epilogue_begin: epilogue_begin = true; break; default: DWARN("unknown standard opcode: %d", opcode); goto next; } } if (emit) { if (address > pc) { /* Found an entry after our target PC. */ if (!have_last) { /* Give up on this program. */ break; } /* Return the last entry. */ *outline = last_line; return (read_filename(&names, outdirname, outbasename, opcode_base, file)); } last_file = file; last_line = line; have_last = true; } if (reset_basic_block) basic_block = false; } goto next; }