void Ts206::writeMem(uint8_t address, uint8_t data)
{
TAKE_CS();
writeBits(WRITE_MODE, 3);
writeBits(address, 6);
writeBits(data, 4);
RELEASE_CS();
}
void putParen(uchar b, BITOUT *bitout) {
if (b == OP) {
writeBits(bitout, OP, 1);
}
else {
writeBits(bitout, CP, 1);
}
}
void Ts206::write(uint8_t address, uint8_t * data, uint8_t cnt)
{
TAKE_CS();
writeBits(WRITE_MODE, 3);
writeBits(address, 6);
for (uint8_t i = 0; i < cnt; i++) writeBits(data[i], 4);
RELEASE_CS();
}
MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainWindow)
{
ui->setupUi(this);
maxLevel = 0;
maxLevel_2 = 0;
this->setWindowTitle(tr("Kazaryan Paint"));
scene = new QGraphicsScene(this);
pixmapItem = scene->addPixmap(QPixmap());
ui->graphicsView->setScene(scene);
scene_2 = new QGraphicsScene(this);
pixmapItem_2 = scene_2->addPixmap(QPixmap());
ui->graphicsView_2->setScene(scene_2);
ui->graphicsView->installEventFilter(this);
ui->graphicsView_2->installEventFilter(this);
ui->graphicsView_3->installEventFilter(this);
ui->graphicsView_4->installEventFilter(this);
//
sceneHist = new QGraphicsScene(this);
pixmapItem_3 = sceneHist->addPixmap(QPixmap());
ui->graphicsView_3->setScene(sceneHist);
sceneHist_2 = new QGraphicsScene(this);
pixmapItem_4 = sceneHist_2->addPixmap(QPixmap());
ui->graphicsView_4->setScene(sceneHist_2);
mA.assign(64, std::vector<double>(64, 0));
for (int i = 0; i < 64; ++i)
for (int j = 0; j < 64; ++j)
{
QBitArray b1(8);
writeBits(i, b1, 0, 7);
QBitArray b2(8);
writeBits(j, b2, 0, 7);
int r = 0;
for (int k = 0; k < b1.size(); ++k)
r += (int) (b1[k] ^ b2[k]);
mA[i][j] = r / 8.0;
}
// Connections
connect(ui->graphicsView->horizontalScrollBar(),
SIGNAL(valueChanged(int)),
ui->graphicsView_2->horizontalScrollBar(),
SLOT(setValue(int)));
connect(ui->graphicsView_2->horizontalScrollBar(),
SIGNAL(valueChanged(int)),
ui->graphicsView->horizontalScrollBar(),
SLOT(setValue(int)));
connect(ui->graphicsView->verticalScrollBar(),
SIGNAL(valueChanged(int)),
ui->graphicsView_2->verticalScrollBar(),
SLOT(setValue(int)));
connect(ui->graphicsView_2->verticalScrollBar(),
SIGNAL(valueChanged(int)),
ui->graphicsView->verticalScrollBar(),
SLOT(setValue(int)));
}
void Ts206::sendCommand(uint8_t cmd, bool first, bool last)
{
if (first)
{
TAKE_CS();
writeBits(COMMAND_MODE, 3);
}
writeBits(cmd, 8);
writeBits(0, 1);
if (last) RELEASE_CS();
}
void uninitRepair (PROG_INFO *prog_struct, BLOCK_INFO *block_struct) {
/*
** If output was sent to a file, then put an end of file marker
** on the prelude file and close both the seq and prel files.
*/
if (prog_struct -> prel_file != NULL) {
writeBits (prog_struct -> prel_file, 1, 1, R_FALSE);
writeBits (prog_struct -> prel_file, 0, 0, R_FALSE);
writeBits (prog_struct -> prel_file, 0, 0, R_FALSE);
writeBits (prog_struct -> prel_file, 0, 0, R_TRUE);
FCLOSE (prog_struct -> seq_file);
FCLOSE (prog_struct -> prel_file);
if (prog_struct -> prel_text_file != NULL) {
FCLOSE (prog_struct -> prel_text_file);
}
}
#ifdef DEBUG
fprintf (stderr, "\nOverall Statistics:\n\n");
fprintf (stderr, "Input filename: %s\n", prog_struct -> base_filename != NULL ? prog_struct -> base_filename : "N/A");
fprintf (stderr, "Input file size: %d\n", prog_struct -> base_filename != NULL ? prog_struct -> in_file_size : 0);
fprintf (stderr, "Total number of phrases: %d\n", prog_struct -> total_num_phrases);
fprintf (stderr, "Total number of blocks: %d\n", prog_struct -> total_blocks);
fprintf (stderr, "Total sequence length: %d\n", prog_struct -> total_num_symbols);
if (prog_struct -> prel_text_file != NULL) {
fprintf (stderr, "Average length of phrases: %f per phrase\n", (R_DOUBLE) prog_struct -> total_sum_phrase_length / (R_DOUBLE) prog_struct -> total_num_phrases);
fprintf (stderr, "The longest phrases was:\n");
fprintf (stderr, "\tphrase number: %d\n", prog_struct -> max_longest_phrase_num);
fprintf (stderr, "\tblock number: %d\n", prog_struct -> max_longest_phrase_block);
fprintf (stderr, "\tphrase length: %d\n", prog_struct -> max_longest_phrase_length);
}
fprintf (stderr, "\nMaximum for one phrase hierarchy:\n");
fprintf (stderr, "\tNumber of primitives and phrases: %d\n", prog_struct -> maximum_total_num_phrases);
fprintf (stderr, "\tGeneration: %d\n", prog_struct -> maximum_generations + 1);
/* Add 1 since generation is 0-based */
fprintf (stderr, "\tNumber of primitives: %d\n", prog_struct -> maximum_primitives);
#endif
/* Must add 1 to maximum_generations since it is 0-based */
if (prog_struct -> verbose_level == R_TRUE) {
fprintf (stderr, "-------------------------------------------------------------------------\n");
fprintf (stderr, "%5u\t%5u\t%7u\t %15u\t%11u\t%7u\n", prog_struct -> total_blocks, prog_struct -> total_num_prims, prog_struct -> total_num_phrases, prog_struct -> total_num_prims + prog_struct -> total_num_phrases, prog_struct -> maximum_generations + 1, prog_struct -> total_num_symbols);
}
wfree (prog_struct -> seq_nodelist);
wfree (prog_struct -> progname);
wfree (prog_struct -> base_filename);
return;
}
static void send(uint8_t value, uint8_t mode) {
GPIO_WriteBit(Lcd_Conf.gpio, Lcd_Conf.rs, mode);
if(Lcd_Conf.rw != 255)
GPIO_ResetBits(Lcd_Conf.gpio, Lcd_Conf.rw);
if(Lcd_Conf.dispFunc & LCD_8BITMODE) {
writeBits(value, 8);
} else {
writeBits(value >> 4, 4);
writeBits(value, 4);
}
}
int _colenc(struct BITSTREAM *bs, int n, const double *store, int col, double scale, int Ml2)
{
#if 0
double h[2];
double emax = 0.0;
#endif
int i;
int nbits = bufferSize(bs);
struct DELTACODE dc;
writeManyBits(bs, (int)scale, 32);
writeBits(bs, Ml2, 8);
#if 1
initDeltaCode(&dc, scale, Ml2);
for (i=0; i<n; i++) {
deltaEncode(&dc, bs, store[6*i+col]);
}
#else
h[0] = h[1] = 0 ;
for (i=0; i<n; i++) {
double p = 2.0*h[0]-h[1];
double d = floor(0.5+scale*(store[6*i+col]-p));
double e = fabs(p+d/scale-store[6*i+col]);
printf("p = %1.16lf, writ d=%1.0lf, Ml2=%d\n",p,d,Ml2);
grsCode(bs, d, Ml2);
h[1] = h[0];
h[0] = p+d/scale;
if (e>emax) emax = e;
}
printf("emax = %le\n",emax);
#endif
return bufferSize(bs) - nbits;
}
int writeEXIHeader(bitstream_t* stream) {
/* init stream */
stream->buffer = 0;
stream->capacity = 8;
return writeBits(stream, 8, 128);
}
I2C_RESULT I2CDev::writeBit(uint8_t devAddr, uint8_t regAddr, uint8_t bitPos, uint8_t level)
{
uint8_t bitMask = 0;
if (level)
bitMask = 1<<bitPos;
return writeBits(devAddr, regAddr, bitMask);
}
void LCD_Begin(uint8_t rows, uint8_t cols, uint8_t dotSize) {
if(rows > 1)
Lcd_Conf.dispFunc |= LCD_2LINE;
if((dotSize != 0) && (rows == 1))
Lcd_Conf.dispFunc |= LCD_5x10DOTS;
delayMicroseconds(50000);
GPIO_ResetBits(Lcd_Conf.gpio, Lcd_Conf.rs);
GPIO_ResetBits(Lcd_Conf.gpio, Lcd_Conf.enable);
if(Lcd_Conf.rw != 255)
GPIO_ResetBits(Lcd_Conf.gpio, Lcd_Conf.rw);
if(!(Lcd_Conf.dispFunc & LCD_8BITMODE)) {
writeBits(0x03, 4);
delayMicroseconds(4500);
writeBits(0x03, 4);
delayMicroseconds(4500);
writeBits(0x03, 4);
delayMicroseconds(150);
writeBits(0x02, 4);
} else {
send(LCD_FUNCTIONSET | Lcd_Conf.dispFunc, LOW);
delayMicroseconds(4500);
send(LCD_FUNCTIONSET | Lcd_Conf.dispFunc, LOW);
delayMicroseconds(150);
send(LCD_FUNCTIONSET | Lcd_Conf.dispFunc, LOW);
}
send(LCD_FUNCTIONSET | Lcd_Conf.dispFunc, LOW);
Lcd_Conf.dispCtrl = LCD_DISPLAYON | LCD_CURSOROFF | LCD_BLINKOFF;
LCD_display();
LCD_clear();
Lcd_Conf.dispMode = LCD_ENTRYLEFT | LCD_ENTRYSHIFTDECREMENT;
send(LCD_ENTRYMODESET | Lcd_Conf.dispMode, LOW);
}
I2C_RESULT I2CDev::writeBits(uint8_t devAddr, uint8_t regAddr, uint8_t bitStart, uint8_t bitLengh, uint8_t data)
{
uint8_t bitMask = 1<<bitStart;
uint8_t i = 0;
while(i < bitLengh - bitStart + 1)
{
bitMask |= ((bitStart << i++) | data);
}
return writeBits(devAddr, regAddr, bitMask);
}
static
void outputCompTxtVar(DICT *dict, FILE *output)
{
uint i, j;
RULE *rule;
BITOUT *bitout;
bitout = createBitout(output);
for (i = 0; i < dict->num_contexts; i++) {
rule = dict->rule[i];
for (j = dict->char_size; j < rule->num_rules; j++) {
writeBits(bitout, rule->left[j], dict->code_len);
writeBits(bitout, rule->right[j], dict->code_len);
}
}
for (i = 0; i < dict->seq_len; i++) {
writeBits(bitout, dict->comp_seq[i], dict->code_len);
}
flushBitout(bitout);
destructBitout(bitout);
}
std::vector<int> MainWindow::colHist(QPixmap &pixmap)
{
std::vector<int> res(64, 0);
QImage img = pixmap.toImage();
for (int y = 0; y < img.height(); ++y)
{
for (int x = 0; x < img.width(); ++x)
{
QRgb pixel = img.pixel(x, y);
QBitArray bArr(3 * 8);
writeBits(qRed(pixel), bArr, 0, 7);
writeBits(qGreen(pixel), bArr, 8, 15);
writeBits(qBlue(pixel), bArr, 16, 23);
int i = (int) bArr[6] + (int) bArr[7] * 2 + (int) bArr[14] * 4
+ (int) bArr[15] * 8 + (int) bArr[22] * 16 + (int) bArr[23] * 32;
++res[i];
}
}
return res;
}
int salvarArbolHuffman(struct nodo *raiz, BYTE *mem)
{
static int pos_mem, pos_pos;
if (raiz != NULL)
{
if (raiz->hizq == NULL) // Hoja
{
writeBits(mem, &pos_mem, &pos_pos, UNO, 1);
writeBits(mem, &pos_mem, &pos_pos, raiz->c, 8);
}
else // NO hoja
{
writeBits(mem, &pos_mem, &pos_pos, 0, 1);
salvarArbolHuffman(raiz->hizq, mem);
salvarArbolHuffman(raiz->hdch, mem);
}
}
return pos_mem;
}
int main(int ac, char *av[])
{
// int i;
int bits ;
int totbits = 0 ;
int n = readfile(av[1]);
// int Ml2 = atoi(av[3]);
struct BITSTREAM bs ;
printf("%d values\n",n);
resetBits(&bs);
// encode header
// NEMC
writeBits(&bs, 'N',8);writeBits(&bs, 'M',8);writeBits(&bs, 'E',8);writeBits(&bs, 'C',8);
writeBits(&bs, '0',8); // version 0
// number of lines
writeBits(&bs, n,32);
// encode time
// bits = timeenc(&bs, n, store);
bits = colenc(&bs, n, store, 0, 1); // ,1
printf("%d bits for time/date encoding (%f per line)\n",bits,(float)bits/n);
bits = colenc(&bs, n, store, 1, 1E7); // , Ml2);
bits += colenc(&bs, n, store, 2, 1E7);//, Ml2);
bits += colenc(&bs, n, store, 3, 1E7);//, Ml2);
printf("%d bits for position encoding (%f per line)\n",bits,(float)bits/n);
bits = colenc(&bs, n, store, 5, 5);//, Ml2);
printf("%d bits for depth encoding (%f per line)\n",bits,(float)bits/n);
flushBits(&bs);
totbits = (bs.bp - bs.bitstream)*8;
printf("real size: %d bytes (%1.1f bits per line)\n",totbits/8,(float)totbits/n);
{
FILE *f = fopen(av[2],"wb");
if (!f) {fprintf(stderr,"could not open file %s\n",av[2]);exit(20);}
fwrite(bs.bitstream,bs.bp - bs.bitstream,1,f);
fclose(f);
}
return 0;
}
int writeFile (char* filename, int rows, int cols, PIXEL* bitmap)
{
int fd, ret;
unsigned int start = DEFAULT_BITMAP_OFFSET;
if(filename) {
if((fd = open(filename, O_RDWR|O_CREAT|O_TRUNC, 0666)) < 0) {
perror("Can't open bmp file to write");
return -1;
}
} else fd = STDOUT_FILENO;
ret = writeHeader (fd, rows, cols, start);
if(ret) return ret;
ret = writeBits(fd, rows, cols, bitmap, start);
if(ret) return ret;
if(filename) close(fd);
return 0;
}
int main( void )
{
int const fd = open( "/dev/usb/lp0", O_RDWR );
if( 0 <= fd )
{
printf( "printer port opened\n" );
SENDCOMMAND( initPrinter );
SENDCOMMAND( rasterMode );
SENDCOMMAND( letterQuality );
// set page height
pprintf( fd, "\x01b*rP%d", PAGEHEIGHT );
write( fd, "\x00", 1 );
SENDCOMMAND( clearImage );
SENDCOMMAND( leftMargin );
SENDCOMMAND( rightMargin );
unsigned char rasterData[WIDTHBYTES];
for( unsigned i = 0 ; i < PAGEHEIGHT ; i++ )
{
memset( rasterData, i, sizeof( rasterData ) );
writeBits( fd, rasterData, sizeof( rasterData ) );
}
SENDCOMMAND( formFeed );
SENDCOMMAND( exitRaster );
//
// read response (status)
//
char prevIn[80];
int numPrev = 0 ;
char inBuf[80];
int numRead ;
unsigned sameCount = 0 ;
while( 0 < ( numRead = read( fd, inBuf, sizeof( inBuf )-1 ) ) )
{
if( ( numRead != numPrev ) || ( 0 != memcmp( inBuf, prevIn, numRead ) ) )
{
printf( "read %u bytes\n", numRead );
for( unsigned i = 0 ; i < numRead ; i++ )
printf( "%02x ", inBuf[i] );
printf( "\n" );
numPrev = numRead ;
memcpy( prevIn, inBuf, numRead );
sameCount = 0 ;
} // change in status
else
{
printf( "%u\r", ++sameCount ); // same data as before
if( 7 == ( sameCount & 7 ) )
write( fd, "\x04", 1 ); // EOT command
}
}
perror( "read" );
close( fd );
printf( "printer port closed\n" );
}
else
perror( "/dev/usb/lp0" );
return 0 ;
}
BYTE comprimir(FILE *fpin, FILE *fpout, struct tablaCod *tabla, int verbose)
/*
* Codifica cada caracter del fichero usando la
* tabla de codificacion creada a partir del
* arbol de Huffman
*/
{
BYTE buf_lec[BUF_SZ], buf_esc[BUF_SZ+1], padding;
int pos_buf_esc=0, pos_pos=0, i, j, nbytes;
struct tablaCod *entry;
float completado=0.0F, inc;
struct stat statbuf;
if (verbose)
{
fstat(fileno(fpin), &statbuf);
inc = (BUF_SZ*100.0F) / statbuf.st_size;
if (inc > 100.0F)
inc=100.0F;
printf("Compressing... 0%%");
}
rewind(fpin);
memset(buf_esc, 0, BUF_SZ+1);
for (;;)
{
nbytes=fread(buf_lec, 1, BUF_SZ, fpin);
if (ferror(fpin))
{
perror("fread: comprimir()");
exit(1);
}
for (i=0; i < nbytes; i++)
{
entry=getEntry(tabla, buf_lec[i]);
for (j=0; j < entry->len; j++)
{
writeBits(buf_esc, &pos_buf_esc, &pos_pos, entry->cod[j], 1);
if (pos_buf_esc == BUF_SZ)
{
fwrite(buf_esc, 1, BUF_SZ, fpout);
if (ferror(fpout))
{
perror("fwrite: comprimir()");
exit(1);
}
buf_esc[0]=buf_esc[BUF_SZ];
memset(buf_esc+1, 0, BUF_SZ);
pos_buf_esc=0;
}
}
}
if (verbose)
{
if ((int)completado == 100)
printf("\b\b");
else if ((int)completado >= 10)
printf("\b");
completado+=inc;
if ((int)completado > 100)
completado=100.0F;
printf("\b\b%d%%", (int)completado);
}
if (feof(fpin))
{
padding=(8-pos_pos) % 8;
if (padding != 0 || pos_buf_esc != 0)
{
fwrite(buf_esc, 1, padding == 0 ? pos_buf_esc : pos_buf_esc+1, fpout);
if (ferror(fpout))
{
perror("fwrite: comprimir()");
exit(1);
}
}
if (verbose && (int)completado < 100)
printf("\b\b\b100%%");
break; // Salimos del for(;;)
}
}
return padding;
}
/** Set full-scale accelerometer range.
* @param range New full-scale accelerometer range setting
* @see getFullScaleAccelRange()
*/
PUBLIC void setFullScaleAccelRange(uint8 range) {
writeBits(LSM6DS0_ADDRESS, CTRL_REG6_XL, LSM6DS0_ACCEL_FS_SEL_BIT, LSM6DS0_ACCEL_FS_SEL_LENGTH, range);
vWaitMicroseconds(500);
}
/** Set full-scale gyroscope range.
* @param range New full-scale gyroscope range value
* @see getFullScaleRange()
* @see MPU6050_GYRO_FS_250
* @see MPU6050_RA_GYRO_CONFIG
* @see MPU6050_GCONFIG_FS_SEL_BIT
* @see MPU6050_GCONFIG_FS_SEL_LENGTH
*/
PUBLIC void setFullScaleGyroRange(uint8 range) {
writeBits(LSM6DS0_ADDRESS, CTRL_REG1_G, LSM6DS0_GYRO_FS_SEL_BIT, LSM6DS0_GYRO_FS_SEL_LENGTH, range);
vWaitMicroseconds(500);
}
PUBLIC void setGyroODR(uint8 rate) {
writeBits(LSM6DS0_ADDRESS, CTRL_REG1_G, LSM6DS0_GYRO_ODR_SEL_BIT, LSM6DS0_GYRO_ODR_SEL_LENGTH, rate);
vWaitMicroseconds(500);
}
int main(int argc, char **argv)
{
mpc_reader reader;
mpc_demux* demux;
mpc_streaminfo si;
mpc_encoder_t e;
unsigned char buffer[16];
mpc_bits_reader r;
mpc_block b;
mpc_uint64_t size;
mpc_status err;
mpc_int64_t start_sample = 0, end_sample = 0;
mpc_uint32_t beg_silence, start_block, block_num, i;
int c;
FILE * in_file;
printf(About);
while ((c = getopt(argc , argv, "s:e:")) != -1) {
switch (c) {
case 's':
start_sample = atoll(optarg);
break;
case 'e':
end_sample = atoll(optarg);
break;
}
}
if(argc - optind != 2)
{
usage(argv[0]);
return 0;
}
err = mpc_reader_init_stdio(&reader, argv[optind]);
if(err < 0) return !MPC_STATUS_OK;
demux = mpc_demux_init(&reader);
if(!demux) return !MPC_STATUS_OK;
mpc_demux_get_info(demux, &si);
if (si.stream_version < 8) {
fprintf(stderr, "this file cannot be edited, please convert it first to sv8 using mpc2sv8\n");
exit(!MPC_STATUS_OK);
}
if (end_sample == 0)
end_sample = si.samples;
else
end_sample += si.beg_silence;
start_sample += si.beg_silence;
if (start_sample < 0 || end_sample > si.samples || end_sample <= start_sample) {
fprintf(stderr, "specified samples bounds out of stream bounds\n");
exit(!MPC_STATUS_OK);
}
beg_silence = start_sample % (MPC_FRAME_LENGTH << si.block_pwr);
start_block = start_sample / (MPC_FRAME_LENGTH << si.block_pwr);
block_num = (end_sample + (MPC_FRAME_LENGTH << si.block_pwr) - 1) /
(MPC_FRAME_LENGTH << si.block_pwr) - start_block;
end_sample -= start_block * (MPC_FRAME_LENGTH << si.block_pwr);
mpc_encoder_init(&e, end_sample, si.block_pwr, 1);
e.outputFile = fopen( argv[optind + 1], "rb" );
if ( e.outputFile != 0 ) {
fprintf(stderr, "Error : output file \"%s\" already exists\n", argv[optind + 1]);
exit(MPC_STATUS_FAIL);
}
e.outputFile = fopen( argv[optind + 1], "w+b" );
e.seek_ref = 0;
writeMagic(&e);
writeStreamInfo( &e, si.max_band, si.ms > 0, end_sample, beg_silence,
si.sample_freq, si.channels);
writeBlock(&e, "SH", MPC_TRUE, 0);
writeGainInfo(&e, 0, 0, 0, 0);
writeBlock(&e, "RG", MPC_FALSE, 0);
in_file = fopen(argv[optind], "rb");
i = si.header_position + 4;
fseek(in_file, i, SEEK_SET);
fread(buffer, 1, 16, in_file);
r.buff = buffer;
r.count = 8;
size = mpc_bits_get_block(&r, &b);
while( memcmp(b.key, "AP", 2) != 0 ) {
if ((err = mpc_check_key(b.key)) != MPC_STATUS_OK) {
fprintf(stderr, "Error : invalid input stream\n");
goto error;
}
if (memcmp(b.key, "EI", 2) == 0)
copy_data(in_file, i, e.outputFile, b.size + size);
i += b.size + size;
fseek(in_file, i, SEEK_SET);
fread(buffer, 1, 16, in_file);
r.buff = buffer;
r.count = 8;
size = mpc_bits_get_block(&r, &b);
}
e.seek_ptr = ftell(e.outputFile);
writeBits (&e, 0, 16);
writeBits (&e, 0, 24); // jump 40 bits for seek table pointer
writeBlock(&e, "SO", MPC_FALSE, 0); // reserve space for seek offset
while( start_block != 0 ) {
if ((err = mpc_check_key(b.key)) != MPC_STATUS_OK) {
fprintf(stderr, "Error : invalid input stream\n");
goto error;
}
if (memcmp(b.key, "AP", 2) == 0)
start_block--;
i += b.size + size;
fseek(in_file, i, SEEK_SET);
fread(buffer, 1, 16, in_file);
r.buff = buffer;
r.count = 8;
size = mpc_bits_get_block(&r, &b);
}
while( block_num != 0 ) {
if ((err = mpc_check_key(b.key)) != MPC_STATUS_OK) {
fprintf(stderr, "Error : invalid input stream\n");
goto error;
}
if (memcmp(b.key, "AP", 2) == 0) {
if ((e.block_cnt & ((1 << e.seek_pwr) - 1)) == 0) {
e.seek_table[e.seek_pos] = ftell(e.outputFile);
e.seek_pos++;
}
e.block_cnt++;
copy_data(in_file, i, e.outputFile, b.size + size);
block_num--;
}
i += b.size + size;
fseek(in_file, i, SEEK_SET);
fread(buffer, 1, 16, in_file);
r.buff = buffer;
r.count = 8;
size = mpc_bits_get_block(&r, &b);
}
writeSeekTable(&e);
writeBlock(&e, "ST", MPC_FALSE, 0); // write seek table block
writeBlock(&e, "SE", MPC_FALSE, 0); // write end of stream block
error:
fclose ( e.outputFile );
fclose ( in_file );
mpc_demux_exit(demux);
mpc_reader_exit_stdio(&reader);
mpc_encoder_exit(&e);
if (err != MPC_STATUS_OK)
remove(argv[optind + 1]);
return err;
}
void putLeaf(uint numcode, uint lvcode, BITOUT *bitout) {
uint bitslen = bits(numcode);
writeBits(bitout, lvcode, bitslen);
}
