/* Returns true if two 32 bit values match */ static inline bool match_32(uint8_t *a, uint8_t *b) { uint32_t *a1 = (uint32_t *) a; uint32_t *b1 = (uint32_t *) b; FILE *file; file = fopen("file.txt","a+"); fprintf(file,"%s","Now printing A "); /*writes*/ printbits(*a1,file); fprintf(file,"%s","\n"); /*writes*/ fprintf(file,"%s","Now printing B "); /*writes*/ printbits(*b1,file); if(*a1 == *b1){ fprintf(file,"%s","They match!"); /*writes*/ } else { fprintf(file,"%s","They DONT match!"); /*writes*/ } fprintf(file,"%s","\n"); /*writes*/ fprintf(file,"%s","\n"); /*writes*/ fclose(file); /*done!*/ return (*a1 == *b1); }
void printfloat(float f) { int32_t t = floatToBits(f); printbits(t, 31, 31); printbits(t, 30, 23); printbits(t, 22, 0); }
void calc_zorder(int size, int *i, int *j, int *level, int levmx, int ibase, int *z_index, int *z_order) { unsigned long long ibit, // Bitwise representation of x-index. jbit; // Bitwise representation of y-index. // Convert the indices to a bitwise representation. int ic; for (ic = 0; ic < size; ic++) { if (level[ic] < 0) continue; ibit = index_to_bit(i[ic], level[ic], levmx, ibase); jbit = index_to_bit(j[ic], level[ic], levmx, ibase); z_index[ic] = twobit_to_index(ibit, jbit); z_order[ic] = ic; } // Sort the z-ordered indices. S7_Index_Sort(z_index, size, S7_INT, z_order); // Output ordered mesh information. if (DEBUG) { printf("orig index i j lev ibit jbit ijbit z index z order\n"); for (ic=0; ic<size; ic++){ printf(" %6d %4d %4d %4d ",ic+1, j[ic], i[ic], level[ic]); printbits(index_to_bit(j[ic], level[ic], levmx, ibase)); printf(" "); printbits(index_to_bit(i[ic], level[ic], levmx, ibase)); printf(" "); printbits( index_to_bit(i[ic], level[ic], levmx, ibase) | (index_to_bit(j[ic], level[ic], levmx, ibase) << 1)); printf(" %6d %5d\n",z_index[ic], z_order[ic]); } } }
int main(void){ int x = 2, y = 3; printbits("x", x); printbits("y", y); printbits("z", setbits(x, 3, 3, y)); }
int main() { char buf[max]; unsigned int x = 0252; int p = 4; int n = 3; snprintf(buf, max, "%s%d%s%d%s", "invert(x,", p, ",", n, ")"); printf("%*s --> \n", w1, buf); printf("%*s --> %*o\n", w1, "x", w2, x); printf("%*s --> ", w1, "x"); printbits(x); invert(x, p, n); x = 0252; p = 0; n = 1; snprintf(buf, max, "%s%d%s%d%s", "invert(x,", p, ",", n, ")"); printf("%*s --> \n", w1, buf); printf("%*s --> %*o\n", w1, "x", w2, x); printf("%*s --> ", w1, "x"); printbits(x); invert(x, p, n); x = 031234567252; p = 31; n = 1; snprintf(buf, max, "%s%d%s%d%s", "invert(x,", p, ",", n, ")"); printf("%*s --> \n", w1, buf); printf("%*s --> %*o\n", w1, "x", w2, x); printf("%*s --> ", w1, "x"); printbits(x); invert(x, p, n); }
int getheader () { unsigned int code, gob; /* look for startcode */ startcode (); code = getbits (PSC_LENGTH); gob = getbits (5); if (gob == SE_CODE) return 0; if (gob == 0) { if (trace) { fprintf (trace_file, "\nPSC: "); printbits ((code << (5 + gob)), 22, 22); } getpicturehdr (); if (syntax_arith_coding) /* reset decoder after receiving */ decoder_reset (); /* fixed length PSC string */ } else { if (trace) { fprintf (trace_file, "\nGBSC: "); printbits ((code << (5 + gob)), 22, 22); } } return gob + 1; }
int main(int argc, char *argv[]) { if (argc < 3) { printf("usage: %s x y\n", argv[0]); return 0; } int x = atoi(argv[1]); int y = atoi(argv[2]); printf("x = 0x%08x %s\n", x, printbits(x, 0)); printf("y = 0x%08x %s\n", y, printbits(y, 0)); int z = x&y; printf("x & y = 0x%x & 0x%x = %s (0x%x)\n", x, y, printbits(z,0), z); z = x|y; printf("x | y = 0x%x & 0x%x = %s (0x%x)\n", x, y, printbits(z,0), z); z = x^y; printf("x ^ y = 0x%x & 0x%x = %s (0x%x)\n", x, y, printbits(z,0), z); z = x^x; printf("x ^ x = 0x%x\n", z); z = ~x; printf("~x = 0x%x = %s\n", z, printbits(z,0)); z = ~y; printf("~y = 0x%x = %s\n", z, printbits(z,0)); x |= 0x20; printf("set 6'th bit for x |= 0x20 = 0x%x, %s\n", x, printbits(x,0)); x &= ~0x20; printf("del 6'th bit for x &= ^0x20 = 0x%x, %s\n", x, printbits(x,0)); return 0; }
void printbits(int length, int number, long long index) { if (length == 0) return ; long long count; count = str[length-1][number]; if (count <= index) { fprintf(fout, "1"); printbits(length-1, number-1, index-count); }else { fprintf(fout, "0"); printbits(length-1, number, index); } }
// Display thte reset reason void display_reset_reason(void) { dprintf("Reset Flag:"); #ifdef DEBUG printbits(RCC_CSR, 32); #endif /* DEBUG */ dprintf("\n"); dprintf("Reset due to: \n"); if (CHECK_BITMASK(RCC_CSR, RCC_CSR_LPWRRSTF)) { dprintf("---> RCC_CSR_LPWRRSTF -- Low Power Reset Flag\n"); } if (CHECK_BITMASK(RCC_CSR, RCC_CSR_WWDGRSTF)) { dprintf("---> RCC_CSR_WWDGRSTF -- Windowed Watchdog Reset Flag\n"); } if (CHECK_BITMASK(RCC_CSR, RCC_CSR_IWDGRSTF)) { dprintf("---> RCC_CSR_IWDGRSTF -- Independent Watchdog Reset Flag\n"); } if (CHECK_BITMASK(RCC_CSR, RCC_CSR_SFTRSTF)) { dprintf("---> RCC_CSR_SFTRSTF -- Software Reset Flag\n"); } if (CHECK_BITMASK(RCC_CSR, RCC_CSR_PORRSTF)) { dprintf("---> RCC_CSR_PORRSTF -- POR/PDR Reset Flag\n"); } if (CHECK_BITMASK(RCC_CSR, RCC_CSR_PINRSTF)) { dprintf("---> RCC_CSR_PINRSTF -- NRST PIN Reset Flag\n"); } if (CHECK_BITMASK(RCC_CSR, RCC_CSR_BORRSTF)) { dprintf("---> RCC_CSR_BORRSTF -- Brown Out Reset Flag\n"); } }
/* * The main method. */ int main(int argc, char *argv[]){ if (argc==1){ printf("Error: No input file specified.\n"); printf("Usage: argv[0] input_file [output_file]\n"); printf("If no output file is specified, the program will print to standard output.\n"); exit(3); } FILE* f = fopen(argv[1], "r"); if (f == NULL) { perror("In encode, error"); exit(3); } huffmantree* tree=frequency_tree(f); char* tree_string=huffmantree_tostring(tree); printf("treestring %s\n", tree_string); rewind(f); FILE* out=stdout; if (argc>2){ out=fopen(argv[2], "w"); } printbits(tree,f,out); huffmantree_free(tree); fclose(f); if(out!=stdout)fclose(out); exit(0); }
int getTMNMV () { int code; if (trace) fprintf (trace_file, "motion_code ("); if (getbits1 ()) { if (trace) fprintf (trace_file, "1): 0\n"); return 0; } if ((code = showbits (12)) >= 512) { code = (code >> 8) - 2; flushbits (TMNMVtab0[code].len); if (trace) { fprintf (trace_file, "0"); printbits (code + 2, 4, TMNMVtab0[code].len); fprintf (trace_file, "): %d\n", TMNMVtab0[code].val); } return TMNMVtab0[code].val; }
/* Initilizes randomly all p memories in XI[p][n] matrix * * PRE: XI != NULL * XI is a [p][n] matrix (ie: holding 'p' memories of 'n' components each) */ void init_XI (unsigned long *XI, unsigned int p, unsigned int n) { int i = 0; assert (XI != NULL); /* NOTE With #pragma statement this section becomes non-deterministic, * as the output memory XI[i] will depend on the execution order of the * execution threads, which itself is non-deterministic. * To regain determinism in the creation of the XI matrix simply * comment the #pragma statement * WARNING mzran13 is NOT threadsafe */ /* #pragma omp parallel for shared(XI) */ for (i=0 ; i<p*n ; i++) { XI[i] = (unsigned long) mzran13(); } debug ("%s","\nXI reinitialized:\n"); dfor(i=0 ; i<p*n ; i++) { debug ("XI[%d][%d] ", i/n, i%n); printbits(XI[i]); } debug ("%s","\n"); return; }
mmio_window_t mmio_window_new( const gchar *title ) { mmio_window_t mmio = g_malloc0( sizeof(struct mmio_window_info) ); int i, j; GtkCList *all_list; GtkWidget *vbox1; GtkWidget *hbuttonbox1; GtkWidget *mmr_close; mmio->window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (mmio->window), title); gtk_window_set_default_size (GTK_WINDOW (mmio->window), 600, 600); vbox1 = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (mmio->window), vbox1); mmio->notebook = gtk_notebook_new (); gtk_box_pack_start (GTK_BOX (vbox1), mmio->notebook, TRUE, TRUE, 0); gtk_notebook_set_tab_pos (GTK_NOTEBOOK (mmio->notebook), GTK_POS_LEFT); hbuttonbox1 = gtk_hbutton_box_new (); gtk_box_pack_start (GTK_BOX (vbox1), hbuttonbox1, FALSE, TRUE, 0); gtk_box_set_spacing (GTK_BOX (hbuttonbox1), 30); mmr_close = gtk_button_new_with_mnemonic (_("Close")); gtk_container_add (GTK_CONTAINER (hbuttonbox1), mmr_close); GTK_WIDGET_SET_FLAGS (mmr_close, GTK_CAN_DEFAULT); /* Add the mmio register data */ all_list = mmio_window_add_page( mmio, "All", NULL ); for( i=0; i < num_io_rgns; i++ ) { GtkCList *list = mmio_window_add_page( mmio, io_rgn[i]->id, io_rgn[i] ); for( j=0; io_rgn[i]->ports[j].id != NULL; j++ ) { int sz = io_rgn[i]->ports[j].width; char addr[10], data[10], bits[40]; char *arr[] = { addr, io_rgn[i]->ports[j].id, data, bits, io_rgn[i]->ports[j].desc }; sprintf( addr, "%08X", io_rgn[i]->base + io_rgn[i]->ports[j].offset ); printhex( data, sz, *io_rgn[i]->ports[j].val ); printbits( bits, io_rgn[i]->ports[j].width, *io_rgn[i]->ports[j].val ); gtk_clist_append( list, arr ); gtk_clist_append( all_list, arr ); } } g_signal_connect ((gpointer) mmio->window, "delete_event", G_CALLBACK (on_mmio_delete_event), NULL); g_signal_connect ((gpointer) mmr_close, "clicked", G_CALLBACK (on_mmio_close_clicked), mmio); gtk_widget_show_all( mmio->window ); return mmio; }
int main(int argc, char *argv[]) { int x = atoi(argv[1]); int p = atoi(argv[2]); int n = atoi(argv[3]); int temp1 = ~0 << n; int temp2 = temp1 << (p+1-n); int temp3 = ~ temp2; printf("x = "); printbits(x); printf("temp1= "); printbits(temp1); printf("temp2= "); printbits(temp2); printf("temp3= "); printbits(temp3); int temp4 = x ^ temp3; printf("temp4= "); printbits(temp4); return 0; }
uint8_t* setdiff(uint8_t* x,uint8_t *y,int nrow)//x-y { int i=0; uint8_t* ret=(uint8_t*)R_alloc(nrow , sizeof(uint8_t)); for(i=0;i<nrow;i++) { uint8_t tmp=(~y[i]); Rprintf("x[%i]=",i); printbits(x[i]); Rprintf("\n"); Rprintf("y[%i]=",i); printbits(y[i]); Rprintf("\n"); Rprintf("tmp=\n"); printbits(tmp); Rprintf("\n"); ret[i]=(x[i]&tmp); } return ret; }
int main(int argc, char* argv[]){ float f; unsigned int i; if (argc < 2) { printf("Too few arguments"); return EXIT_FAILURE; } f = atof(argv[1]); i = ftoi(f); printbits(i, SBITS, EBITS-1); printf(" "); printbits(i, EBITS, MBITS-1); printf(" "); printbits(i, MBITS, sizeof(f)*8-1); printf("\n"); return EXIT_SUCCESS; }
int main(int argc, char**argv) { long int x; int fd; size_t cnt; unsigned char _buf[BUILTIN_BUF_LEN] = {0}; unsigned char *buf = _buf; if(argc != 2) return 1; switch(x = strtol((const char*)argv[1], NULL, 0xA)) { case LONG_MIN: case LONG_MAX: perror("Invalid argument"); return 1; default: break; } cnt = (size_t) (x < 0 ? 0 : x); if(cnt > BUILTIN_BUF_LEN) { if((buf = malloc(sizeof(char)*cnt)) == NULL) { perror("Memory allocation error"); return 1; } memset(buf, 0, cnt); } if((fd = open("/dev/urandom", O_RDONLY)) == -1) { perror("Failed to open /dev/urandom"); FREEBUF(buf, _buf); return 1; } if(read(fd, buf, cnt) == -1) { perror("Couldn't read from /dev/urandom"); close(fd); FREEBUF(buf, _buf); return 1; } for(x = 0; x < cnt; x++) printbits(buf[x]); putchar('\n'); close(fd); FREEBUF(buf, _buf); return 0; }
void print_tree(NODE *node, unsigned int pos, unsigned int depth){ //puts("printing tree structure:"); //puts("1 is a left turn, 0 is a right turn, root starts at 0"); printf("pos, depth(%d): ", depth); printbits(pos, depth-1); printf("\t{%G, %G, %G}\t%u\n", node->val[0], node->val[1], node->val[2], node); if(node->left != NULL){ pos = pos << 1; pos++; print_tree(node->left, pos, depth+1); pos--; pos = pos >> 1; }
int main() { FILE *fin = fopen("kimbits.in", "r"); fout = fopen("kimbits.out", "w"); int length, number, i; long long index; fscanf(fin, "%d %d %lld\n", &length, &number, &index); initStr(); //for (i = 1; i <= 19; i++) { printbits(length, number, index-1); fprintf(fout, "\n"); //} fclose(fin); fclose(fout); }
/* Function * * Return x with the n bits that begin at position p inverted * * */ unsigned int invert(unsigned int x, int p, int n) { /* examples in comments show low order 8 bits * p = 4 * n = 3 * x = 1010 1010 */ unsigned int mh = ~0 << (p + 1); /* mask high eg 1110 0000 */ /* the following cludge was required because shifting 1000 by * 1 to the left resulted in 1111 instead of 0000 as expected * (probably due to rounding up in order to try and represent * a number outside the range of the word size) */ if (p == ((sizeof(x) * CHAR_BIT) - 1)) mh = 0; printf("%*s --> ", w1, "mh"); printbits(mh); unsigned int ml = ~(~0 << (p + 1 - n)); /* mask low eg 0000 0011 */ printf("%*s --> ", w1, "ml"); printbits(ml); unsigned int ma = mh | ml; /* mask and eg 1110 0011 */ printf("%*s --> ", w1, "ma"); printbits(ma); unsigned int x0 = x & ma; /* x0 is eg 1010 0010 */ printf("%*s --> ", w1, "x0"); printbits(x0); unsigned int xa = x & ~ma; /* xa is eg 0000 1000 */ printf("%*s --> ", w1, "xa"); printbits(xa); unsigned int xc = ~xa & ~ma; /* xc is eg 0001 0100 */ printf("%*s --> ", w1, "xc"); printbits(xc); unsigned int re = xc | x0; /* return eg 1011 0110 */ printf("%*s --> ", w1, "re"); printbits(re); printf("%*s --> %*o\n", w1, "re", w2, re); return re; }
void mmio_window_update( mmio_window_t mmio ) { int i,j, count = 0; GtkCList *page, *all_page; char data[10], bits[40]; all_page = GTK_CLIST(gtk_object_get_data( GTK_OBJECT(mmio->window), "All" )); for( i=0; i < num_io_rgns; i++ ) { page = GTK_CLIST(gtk_object_get_data( GTK_OBJECT(mmio->window), io_rgn[i]->id )); for( j=0; io_rgn[i]->ports[j].id != NULL; j++ ) { if( *io_rgn[i]->ports[j].val != *(uint32_t *)(io_rgn[i]->save_mem+io_rgn[i]->ports[j].offset)){ int sz = io_rgn[i]->ports[j].width; /* Changed */ printhex( data, sz, *io_rgn[i]->ports[j].val ); printbits( bits, sz, *io_rgn[i]->ports[j].val ); gtk_clist_set_text( page, j, 2, data ); gtk_clist_set_text( page, j, 3, bits ); gtk_clist_set_foreground( page, j, &gui_colour_changed ); gtk_clist_set_text( all_page, count, 2, data ); gtk_clist_set_text( all_page, count, 3, bits ); gtk_clist_set_foreground( all_page, count, &gui_colour_changed ); } else { gtk_clist_set_foreground( page, j, &gui_colour_normal ); gtk_clist_set_foreground( all_page, count, &gui_colour_normal ); } count++; } memcpy( io_rgn[i]->save_mem, io_rgn[i]->mem, LXDREAM_PAGE_SIZE ); } }
void treePop(int* splits, double* w,int* ncolp,int* np, int* ed1, int* ed2, double* edLen) { int n=*np; int ncol=*ncolp; int nrow=ceil(n/(double)8); uint8_t split[nrow][ncol]; int i=0,j=0; /*Rprintf("n=%i nrow=%i ncol=%i\n",n,nrow,ncol); Rprintf("got\n"); for(i=0;i<ncol;i++) { for(j=0;j<nrow;j++) { Rprintf("%i ",splits[i*nrow+j]); } Rprintf("\n"); }*/ for(i=0;i<ncol;i++) { for(j=0;j<nrow;j++) { split[j][i]=(uint8_t)splits[i*nrow+j]; } } /*Rprintf("short-ed\n"); for(i=0;i<nrow;i++) { for(j=0;j<ncol;j++) { printbits(split[i][j]); Rprintf("\n"); } Rprintf("\n"); }*/ uint8_t vlabs[2*n-1][nrow]; for(i=0;i<nrow-1;i++) { vlabs[n+1][i]=255; } vlabs[n+1][nrow-1]=~((uint8_t)(pow(2,8-(n%8))-1)); int bitt_count[ncol]; uint8_t msk=~((uint8_t)(pow(2,8-(n%8))-1));//mask out trailing bits printbits(msk); for(i=0;i<ncol;i++) { int sum=0; for(j=0;j<nrow-1;j++) { //Rprintf("countbits(%i)=%i ",split[j][i],count_bits(split[j][i])); sum+=count_bits(split[j][i]); } uint8_t bt=split[nrow-1][i]; bt&=msk; //Rprintf("countbits(%i)=%i ",bt,count_bits(bt)); sum+=count_bits(bt); // Rprintf("bit_count[%i]=%i ",i,sum); //Rprintf("\n"); if(sum>n/2) { for(j=0;j<nrow;j++) { split[j][i]=~split[j][i]; } split[nrow-1][i]&=msk; sum=n-sum; } bitt_count[i]=sum; } int ind[ncol]; for(i=0;i<ncol;i++) { ind[i]=i; } for(i=0;i<ncol-1;i++) { for(j=i+1;j<ncol;j++) { if(bitt_count[i]<bitt_count[j]) { int aux; aux=bitt_count[i]; bitt_count[i]=bitt_count[j]; bitt_count[j]=aux; aux=ind[i]; ind[i]=ind[j]; ind[j]=aux; } } } int nNodes=n+1; int numEdges=0; for(i=0;i<ncol;i++) { int ii=0; //Rprintf("split %i\n",i); uint8_t sp[nrow]; for(ii=0;ii<nrow;ii++) {//copy split into sp sp[ii]=split[ii][ind[i]]; } //search for node whose labellings are a superset of the current split for(j=n+1;j<=nNodes;j++) { uint8_t vl[nrow]; for(ii=0;ii<nrow;ii++) {//copy vertex labeling into vl vl[ii]=vlabs[j][ii]; } int sw=0;//print current split for(ii=0;ii<nrow;ii++) { //Rprintf("sp[%i]= ",ii); //printbits(sp[ii]); } //Rprintf("\n");//print current label for(ii=0;ii<nrow;ii++) { // Rprintf("vl[%i]= ",ii); // printbits(vl[ii]); } //Rprintf("\n"); uint8_t* sd=setdiff(sp,vl,nrow); //print the setdifference for(ii=0;ii<nrow/*-1*/;ii++) { //Rprintf("sd[%i]=%i ",ii,sd[ii]); if(sd[ii]!=0)sw=1; } // Rprintf("\n"); sd[nrow-1]&=msk; //Rprintf("sd[%i]=%i ",nrow-1,sd[nrow-1]); if(sd[nrow-1]!=0)sw=1; if(sw==0)//setdiff==0, so we split vertex j { // Rprintf("vertex %i",j); ed1[numEdges]=j; int gn=-1; // Rprintf("bitt_count[%i]=%i\n",i,bitt_count[i]); if(bitt_count[i]>=2)//if not trivial split {nNodes++; gn=nNodes; } else { gn=lsb(sp); } // Rprintf("gn=%i\n",gn); ed2[numEdges]=gn; edLen[numEdges]=w[ind[i]]; numEdges++; uint8_t* sdd=setdiff(vl,sp,nrow); for(ii=0;ii<nrow;ii++)//label current vertex byset difference //and new vertex by actual split { vlabs[j][ii]=sdd[ii]; vlabs[gn][ii]=sp[ii]; } //print new labels // Rprintf("new v\n"); int jj=0; for(ii=1;ii<=nNodes;ii++) {//Rprintf("node %i : ",ii); for(jj=0;jj<nrow;jj++) { //printbits(vlabs[ii][jj]); // Rprintf(" "); } // Rprintf("\n"); } break; } } } }
static void getpicturehdr () { int pos, pei, tmp; int UFEP = 0; int BCI = 0; int clock_conversion_code = 0; int clock_divisor = 0; int extended_temporal_reference = 0; int prev_plus_P_temp_ref = 0; pos = ld->bitcnt; prev_plus_P_temp_ref = temp_ref; temp_ref = getbits (8); if (trace) { fprintf (trace_file, "\nTR: "); printbits (temp_ref, 8, 8); } if (trd < 0) trd += 256; tmp = getbits (1); /* always "1" */ if (trace) fprintf (trace_file, "\nSpare: %d", tmp); if (!tmp) if (!quiet) printf ("warning: spare in picture header should be \"1\"\n"); tmp = getbits (1); /* always "0" */ if (trace) fprintf (trace_file, "\nH.261 distinction bit: %d", tmp); if (tmp) if (!quiet) printf ("warning: H.261 distinction bit should be \"0\"\n"); tmp = getbits (1); /* split_screen_indicator */ if (trace) fprintf (trace_file, "\nsplit_screen_indicator: %d", tmp); if (tmp) { if (!quiet) printf ("error: split-screen not supported in this version\n"); exit (-1); } tmp = getbits (1); /* document_camera_indicator */ if (trace) fprintf (trace_file, "\ndocument_camera_indicator: %d", tmp); if (tmp) if (!quiet) printf ("warning: document camera indicator not supported in this version\n"); tmp = getbits (1); /* freeze_picture_release */ if (trace) fprintf (trace_file, "\nfreeze_picture_release: %d", tmp); if (tmp) if (!quiet) printf ("warning: frozen picture not supported in this version\n"); tmp = getbits (3); if (trace) { fprintf (trace_file, "\nsource_format: "); printbits (tmp, 3, 3); } if (tmp == EXTENDED_PTYPE) { if (trace) fprintf (trace_file, "\n----------EXTENDED_PTYPE----------"); plus_type = 1; UFEP = getbits (3); if (trace) { fprintf (trace_file, "\nUFEP: "); printbits (UFEP, 3, 3); } if (UFEP == 1) { /* OPPTYPE */ if (trace) fprintf (trace_file, "\n----------OPTIONAL PLUS PTYPE----------"); source_format_old = source_format; source_format = getbits (3); if (trace) { fprintf (trace_file, "\nsource_format: "); printbits (source_format, 3, 3); } /* optional custom picture clock frequency */ optional_custom_PCF = getbits (1); if (trace) { fprintf (trace_file, "\noptional_custom_PCF: "); printbits (optional_custom_PCF, 1, 1); } if (optional_custom_PCF) { if (!quiet) printf ("error: Optional custom picture clock frequency is not supported in this version\n"); exit (-1); } mv_outside_frame = getbits (1); if (trace) { fprintf (trace_file, "\nmv_outside_frame: "); printbits (mv_outside_frame, 1, 1); } long_vectors = (mv_outside_frame ? 1 : 0); syntax_arith_coding = getbits (1); if (trace) { fprintf (trace_file, "\nsyntax_arith_coding: "); printbits (syntax_arith_coding, 1, 1); } adv_pred_mode = getbits (1); if (trace) { fprintf (trace_file, "\nadv_pred_mode: "); printbits (adv_pred_mode, 1, 1); } mv_outside_frame = (adv_pred_mode ? 1 : mv_outside_frame); overlapping_MC = (adv_pred_mode ? 1 : 0); use_4mv = (adv_pred_mode ? 1 : 0); pb_frame = 0; advanced_intra_coding = getbits (1); if (trace) { fprintf (trace_file, "\nadvanced_intra_coding: "); printbits (advanced_intra_coding, 1, 1); } deblocking_filter_mode = getbits (1); if (trace) { fprintf (trace_file, "\ndeblocking_filter_mode: "); printbits (deblocking_filter_mode, 1, 1); } mv_outside_frame = (deblocking_filter_mode ? 1 : mv_outside_frame); use_4mv = (deblocking_filter_mode ? 1 : use_4mv); slice_structured_mode = getbits (1); if (trace) { fprintf (trace_file, "\nslice_structured_mode: "); printbits (slice_structured_mode, 1, 1); } if (slice_structured_mode) { if (!quiet) printf ("error: Slice structured mode is not supported in this version\n"); exit (-1); } reference_picture_selection_mode = getbits (1); if (trace) { fprintf (trace_file, "\nreference_picture_selection_mode: "); printbits (reference_picture_selection_mode, 1, 1); } #if 0 if (reference_picture_selection_mode) { if (!quiet) printf ("error: Reference picture selection mode is not supported in this version\n"); exit (-1); } #endif independently_segmented_decoding_mode = getbits (1); if (trace) { fprintf (trace_file, "\nindependently_segmented_decoding_mode: "); printbits (independently_segmented_decoding_mode, 1, 1); } if (independently_segmented_decoding_mode) { if (!quiet) printf ("error: Independently segmented decoding mode is not supported in this version\n"); exit (-1); } alternative_inter_VLC_mode = getbits (1); if (trace) { fprintf (trace_file, "\nalternative_inter_VLC_mode: "); printbits (alternative_inter_VLC_mode, 1, 1); } modified_quantization_mode = getbits (1); if (trace) { fprintf (trace_file, "\nmodified_quantization_mode: "); printbits (modified_quantization_mode, 1, 1); } tmp = getbits (4); if (trace) { fprintf (trace_file, "\nspare, reserve, reserve, reserve: "); printbits (tmp, 4, 4); } if (tmp != 8) { /* OPPTYPE : bit15=1, bit16,bit17,bit18=0 */ if (!quiet) printf ("error: The last 4 bits of OPPTYPE is expected to be 1000\n"); exit (-1); } } if ((UFEP == 1) || (UFEP == 0)) { if (UFEP == 0) { if (scalability_mode >= 3) { horizontal_size = lines[base_source_format]; vertical_size = pels[base_source_format]; mb_width = horizontal_size / 16; mb_height = vertical_size / 16; /* Need to store previous (reference layer) values * for interpolation purposes, as the new values, * i.e. of the spatially scaled layer, depend on * the type of spatial scalability in use. */ ref_coded_picture_width = coded_picture_width = horizontal_size; ref_coded_picture_height = coded_picture_height = vertical_size; ref_chrom_width = chrom_width = coded_picture_width >> 1; ref_chrom_height = chrom_height = coded_picture_height >> 1; source_format = base_source_format; } } /* MMPTYPE */ if (trace) fprintf (trace_file, "\n----------MANDATORY PLUS PTYPE----------"); pict_type = getbits (3); if (trace) { fprintf (trace_file, "\npict_type: "); printbits (pict_type, 3, 3); } if (pict_type == PCT_IPB) pb_frame = IM_PB_FRAMES; else pb_frame = 0; if (PCT_B == pict_type) { true_B_frame = ON; /* Allow motion over picture boundaries, regardless of whether or * not UMV is turned on. */ mv_outside_frame = 1; true_b_trb = temp_ref - prev_non_disposable_temp_ref; } else { true_B_frame = OFF; prev_non_disposable_temp_ref = next_non_disposable_temp_ref; next_non_disposable_temp_ref = temp_ref; trd = temp_ref - prev_non_disposable_temp_ref; } reference_picture_resampling_mode = getbits (1); if (trace) { fprintf (trace_file, "\nreference_picture_resampling_mode: "); printbits (reference_picture_resampling_mode, 1, 1); } if (reference_picture_resampling_mode) { if (!quiet) printf ("error: Reference picture resampling mode is not supported in this version\n"); exit (-1); } reduced_resolution_update_mode = getbits (1); if (trace) { fprintf (trace_file, "\nreduced_resolution_update_mode: "); printbits (reduced_resolution_update_mode, 1, 1); } if (reduced_resolution_update_mode) { if (!quiet) printf ("error: Reduced resolution update mode is not supported in this version\n"); exit (-1); } rtype = getbits (1); /* rounding type */ if (trace) { fprintf (trace_file, "\nrounding_type: "); printbits (rtype, 1, 1); } if (trace) { fprintf (trace_file, "\nrtype: "); printbits (rtype, 1, 1); } tmp = getbits (3); if (trace) { fprintf (trace_file, "\nreserve, reserve, spare: "); printbits (tmp, 3, 3); } if (tmp != 1) { /* MPPTYPE : bit7,bit8=0 bit9=1 */ if (!quiet) exit (-1); } } else { /* UFEP is neither 001 nor 000 */ if (!quiet)
void print8bits(uint8_t n) { printbits(n, 8); }
/* Jumps one time-step ahead in time, for all the neurons in the neural network * This is done updating each neuron stored in 'S', and registering in 'm' all * the new overlaps between 'S' and each 'XI[mu]' * * It uses DETERMINISTIC logic * * PRE: S != NULL * S is an [n] dimensional vector * XI != NULL * XI is a [p][n] matrix (ie: holding 'p' memories of 'n' components each) * m != NULL * m is a [p] dimensional vector */ static void update_deterministic_network (unsigned long *S, unsigned long *XI, long *m, unsigned int n, unsigned int p) { int i = 0, j = 0, mu = 0; unsigned long oldSi = 0, mask = 0; long h = 0, exced = 0, XImui = 0; assert (S != NULL); assert (XI != NULL); assert (m != NULL); /* Updating each neuron. * With 'i' we step on a position within S, and with 'j' we access * (one bit at a time) all 'MSB' neurons stored there. * Usually MSB == 64 */ for (i=0 ; i<n ; i++) { for (j=LSB ; j<MSB ; j++) { mask = ((long) 1) << j; h = 0; for (mu=0 ; mu<p ; mu++) { XImui = XI[(mu*n)+i] & mask; h += norm(XImui) * m[mu]; } oldSi = S[i]; exced = ((long) p) * norm(S[i]&mask); /* NOTE exced = p * S[i] */ debug ("S[%d] before bit %lu flip:\n", i, i*MSB+j); dfor(int k=0 ; k<n ; k++) printbits(S[k]); /* If h >= 0 then mask holds the position of the bit * * we have to set (to 1) in S[i] * * Otherwise mask's bitwise negation has a single '0' * * in the exact position of the bit we have to reset */ if (h - exced >= 0) { S[i] |= mask; } else { S[i] &= ~mask; } debug ("S[%d] after:\n", i); dfor (int k=0 ; k<n ; k++) printbits(S[k]); debug ("%s","\n"); /* Recalculating overlaps in m (if needed) */ if (S[i] != oldSi) { update_overlaps (S, XI, m, n, p); debug ("\n\t> S[%d]: flip bit %lu\n", i, i*MSB+j); dfor(int k=0 ; k<n ; k++) { debug ("%s","\t"); printbits(S[k]); } } } }
void printhalf(uint16_t t) { printbits(t, 15, 15); printf(" "); printbits(t, 14, 10); printbits(t, 9, 0); }
void print16bits(uint16_t n) { printbits(n, 16); }
void print32bits(uint32_t n) { printbits(n, 32); }