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;
}
