view release on metacpan or  search on metacpan

Lzma.xs  view on Meta::CPAN

uint32_t
lzma_version_number()

const char *
lzma_version_string()

#define MY_LZMA_VERSION_STRING() LZMA_VERSION_STRING
const char *
MY_LZMA_VERSION_STRING()

#define MY_LZMA_FILTER_LZMA1() LZMA_FILTER_LZMA1
uint64_t
MY_LZMA_FILTER_LZMA1()

#define MY_LZMA_BACKWARD_SIZE_MAX() LZMA_BACKWARD_SIZE_MAX
uint64_t
MY_LZMA_BACKWARD_SIZE_MAX()

lzma_bool
lzma_mf_is_supported(match_finder)
    lzma_match_finder match_finder

lzma_bool
lzma_mode_is_supported(mode)
    lzma_mode mode

lzma_bool
lzma_check_is_supported(check)
    lzma_check check

uint32_t
lzma_check_size(check)
    lzma_check check

size_t
lzma_stream_buffer_bound(uncompressed_size)
    size_t uncompressed_size

lzma_bool
lzma_filter_encoder_is_supported(id)
    lzma_vli id

lzma_bool
lzma_filter_decoder_is_supported(id)
    lzma_vli id

uint64_t
lzma_easy_encoder_memusage(preset)
    uint32_t preset

uint64_t
lzma_easy_decoder_memusage(preset)
    uint32_t preset

void
lzma_alone_encoder(Class, flags, bufsize, filters)
    const char * Class
    int flags
    uLong bufsize
    AV* filters
  PPCODE:
  {
    lzma_ret err = LZMA_OK;
    deflateStream s = NULL;

    if ((s = InitStream() )) {
        setupFilters(s, filters, NULL);
        err = lzma_alone_encoder ( &(s->stream), (const lzma_options_lzma*)s->filters[0].options );

        if (err != LZMA_OK) {
            Safefree(s) ;
            s = NULL ;
        }
        else {
            PostInitStream(s, flags, bufsize) ;
            //s->is_tainted = is_tainted;
        }
    }
    else {
        err = LZMA_MEM_ERROR ;
        s = NULL;
    }

    {
        SV* obj = sv_setref_pv(sv_newmortal(), Class, (void*)s);
        //if (is_tainted)
            //setTainted(obj);
        XPUSHs(obj);
    }
    if (GIMME_V == G_ARRAY) {
        SV * sv = sv_2mortal(newSViv(err)) ;
        setDUALstatus(sv, err);
        //if (is_tainted)
            //setTainted(sv);
        XPUSHs(sv) ;
    }
  }

void
lzma_raw_encoder(Class, flags, bufsize, filters, forZip)
    const char * Class
    int flags
    uLong bufsize
    AV* filters
    bool forZip
  PPCODE:
  {
    lzma_ret err = LZMA_OK;
    deflateStream s = NULL;
    if ((s = InitStream() )) {
        setupFilters(s, filters, NULL);

        s->forZip = forZip ;
        err = lzma_raw_encoder ( &(s->stream), (const lzma_filter*)&s->filters );

        if (err != LZMA_OK) {
            Safefree(s) ;
            s = NULL ;
        }
        else {
            PostInitStream(s, flags, bufsize) ;
            //s->is_tainted = is_tainted;
        }
    }
    else {
        err = LZMA_MEM_ERROR ;
        s = NULL;
    }

    {
        SV* obj = sv_setref_pv(sv_newmortal(), Class, (void*)s);
        //if (is_tainted)
            //setTainted(obj);
        XPUSHs(obj);
    }
    if (GIMME_V == G_ARRAY) {
        SV * sv = sv_2mortal(newSViv(err)) ;
        setDUALstatus(sv, err);
        //if (is_tainted)
            //setTainted(sv);
        XPUSHs(sv) ;
    }
  }

void
lzma_stream_encoder(Class, flags, bufsize, filters, check=LZMA_CHECK_CRC32)
    const char * Class
    int flags
    uLong bufsize
    AV* filters
    lzma_check check
  PPCODE:
  {
    lzma_ret err = LZMA_OK;
    deflateStream s = NULL;

    if ((s = InitStream() )) {
        setupFilters(s, filters, NULL);

        err = lzma_stream_encoder ( &(s->stream), (const lzma_filter*)&s->filters, check );

        if (err != LZMA_OK) {
            Safefree(s) ;
            s = NULL ;
        }
        else {
            PostInitStream(s, flags, bufsize) ;
            //s->is_tainted = is_tainted;
        }
    }
    else {
        err = LZMA_MEM_ERROR ;
        s = NULL;
    }

    {
        SV* obj = sv_setref_pv(sv_newmortal(), Class, (void*)s);
        //if (is_tainted)
            //setTainted(obj);
        XPUSHs(obj);
    }
    if (GIMME_V == G_ARRAY) {
        SV * sv = sv_2mortal(newSViv(err)) ;
        setDUALstatus(sv, err);
        //if (is_tainted)
            //setTainted(sv);
        XPUSHs(sv) ;
    }
  }


void
lzma_easy_encoder(Class, flags, bufsize, preset=LZMA_PRESET_DEFAULT, check=LZMA_CHECK_CRC32)
    const char * Class
    int flags
    int preset
    lzma_check check
    uLong bufsize
  PPCODE:
  {
    lzma_ret err = LZMA_OK;
    deflateStream s = NULL;

    if ((s = InitStream())) {
        err = lzma_easy_encoder ( &(s->stream), preset, check);

        if (err != LZMA_OK) {
            Safefree(s) ;
            s = NULL ;
        }
        else {
            PostInitStream(s, flags, bufsize) ;
            //s->is_tainted = is_tainted;
        }
    }
    else {
        err = LZMA_MEM_ERROR ;
        s = NULL;
    }

    {
        SV* obj = sv_setref_pv(sv_newmortal(), Class, (void*)s);
        //if (is_tainted)
            //setTainted(obj);
        XPUSHs(obj);
    }
    if (GIMME_V == G_ARRAY) {
        SV * sv = sv_2mortal(newSViv(err)) ;
        setDUALstatus(sv, err);
        //if (is_tainted)
            //setTainted(sv);
        XPUSHs(sv) ;
    }
  }



MODULE = Compress::Raw::Lzma::Encoder PACKAGE = Compress::Raw::Lzma::Encoder


void
DESTROY(s)
    Compress::Raw::Lzma::Encoder	s
  CODE:
    lzma_end(&s->stream) ;
    destroyStream(s) ;



DualType
code (s, buf, output)
    Compress::Raw::Lzma::Encoder	s
    SV *	buf
    SV * 	output
    uInt	cur_length = NO_INIT
    uInt	increment = NO_INIT
    lzma_ret	RETVAL = LZMA_OK;
    uInt   bufinc = NO_INIT
    //bool is_tainted  = getTaint3;

Lzma.xs  view on Meta::CPAN

            increment = bufinc ;
            s->stream.avail_out = increment;
            bufinc *= 2 ;
        }

        RETVAL = lzma_code(&(s->stream), f);

        /* deflate has finished flushing only when it hasn't used up
         * all the available space in the output buffer:
         */
        /* if (s->stream.avail_out != 0 || RETVAL < 0 ) */
        if (RETVAL != LZMA_OK)
            break;
    }

    s->last_error = RETVAL ;

    s->compressedBytes    += cur_length + increment - s->stream.avail_out ;

    if (RETVAL == LZMA_STREAM_END) {
        SvPOK_only(output);
        SvCUR_set(output, cur_length + increment - s->stream.avail_out) ;
        SvSETMAGIC(output);
    }
    OUTPUT:
	RETVAL


uLong
compressedBytes(s)
    Compress::Raw::Lzma::Encoder	s
    CODE:
        //bool is_tainted = getTaint1;
        RETVAL = s->compressedBytes;
  OUTPUT:
	RETVAL

uLong
uncompressedBytes(s)
    Compress::Raw::Lzma::Encoder	s
    CODE:
        //bool is_tainted = getTaint1;
        RETVAL = s->uncompressedBytes;
  OUTPUT:
	RETVAL



MODULE = Compress::Raw::Lzma PACKAGE = Compress::Raw::Lzma

void
lzma_auto_decoder(Class, flags, bufsize, memlimit=UINT64_MAX, fl=0)
    const char* Class
    int flags
    int fl
    uint64_t memlimit
    uLong bufsize
  ALIAS:
    lzma_stream_decoder = 1
    lzma_alone_decoder  = 2
  PPCODE:
  {
    int err = LZMA_OK ;
    inflateStream s = NULL;
    if ((s = InitStream() )) {
        if (ix == 0)
            err = lzma_auto_decoder ( &(s->stream), memlimit, fl );
        else if (ix == 1)
            err = lzma_stream_decoder ( &(s->stream), memlimit, fl );
        else if (ix == 2)
            err = lzma_alone_decoder ( &(s->stream), memlimit );

        if (err != LZMA_OK) {
            Safefree(s) ;
            s = NULL ;
	}
	if (s) {
            //s->is_tainted = is_tainted;
	    PostInitStream(s, flags, bufsize) ;
        }
    }
    else
        err = LZMA_MEM_ERROR ;

    {
        SV* obj = sv_setref_pv(sv_newmortal(), Class, (void*)s);
        //if (is_tainted)
            //setTainted(obj);
        XPUSHs(obj);
    }
    if (GIMME_V == G_ARRAY) {
        SV * sv = sv_2mortal(newSViv(err)) ;
        setDUALstatus(sv, err);
        //if (is_tainted)
            //setTainted(sv);
        XPUSHs(sv) ;
    }
  }

void
lzma_raw_decoder(Class, flags, bufsize, filters, properties)
    const char* Class
    int flags
    uLong bufsize
    AV* filters
    const char* properties
  PPCODE:
  {
    int err = LZMA_OK ;
    inflateStream s = NULL;
    if ((s = InitStream() )) {

        if (! setupFilters(s, filters, properties)) {
            Safefree(s) ;
            s = NULL ;
        }

        err = lzma_raw_decoder ( &(s->stream), (const lzma_filter*)&s->filters );

        if (err != LZMA_OK) {
            Safefree(s) ;
            s = NULL ;
	}
	if (s) {
            //s->is_tainted = is_tainted;
	    PostInitStream(s, flags, bufsize) ;
        }
    }
    else
        err = LZMA_MEM_ERROR ;

    {
        SV* obj = sv_setref_pv(sv_newmortal(), Class, (void*)s);
        //if (is_tainted)
            //setTainted(obj);
        XPUSHs(obj);
    }
    if (GIMME_V == G_ARRAY) {
        SV * sv = sv_2mortal(newSViv(err)) ;
        setDUALstatus(sv, err);
        //if (is_tainted)
            //setTainted(sv);
        XPUSHs(sv) ;
    }
  }

MODULE = Compress::Raw::Lzma::Decoder PACKAGE = Compress::Raw::Lzma::Decoder

void
DESTROY(s)
    Compress::Raw::Lzma::Decoder	s
  CODE:
    lzma_end(&s->stream) ;
    destroyStream(s) ;


DualType
code (s, buf, output)
    Compress::Raw::Lzma::Decoder	s
    SV *	buf
    SV * 	output
    uInt	cur_length = 0;
    uInt	prefix_length = 0;
    uInt	increment = 0;
    uInt    bufinc = NO_INIT
    STRLEN  na = NO_INIT ;
    STRLEN  origlen = NO_INIT