cobalt / cobalt / c22907dbc00f1b681ca5a66f4cbc333d84fae0a5 / . / src / third_party / opus / celt / entenc.h

/* Copyright (c) 2001-2011 Timothy B. Terriberry | |

Copyright (c) 2008-2009 Xiph.Org Foundation */ | |

/* | |

Redistribution and use in source and binary forms, with or without | |

modification, are permitted provided that the following conditions | |

are met: | |

- Redistributions of source code must retain the above copyright | |

notice, this list of conditions and the following disclaimer. | |

- Redistributions in binary form must reproduce the above copyright | |

notice, this list of conditions and the following disclaimer in the | |

documentation and/or other materials provided with the distribution. | |

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | |

``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | |

LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | |

A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER | |

OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, | |

EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, | |

PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR | |

PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF | |

LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING | |

NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS | |

SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |

*/ | |

#if !defined(_entenc_H) | |

# define _entenc_H (1) | |

# include <stddef.h> | |

# include "entcode.h" | |

/*Initializes the encoder. | |

_buf: The buffer to store output bytes in. | |

_size: The size of the buffer, in chars.*/ | |

void ec_enc_init(ec_enc *_this,unsigned char *_buf,opus_uint32 _size); | |

/*Encodes a symbol given its frequency information. | |

The frequency information must be discernable by the decoder, assuming it | |

has read only the previous symbols from the stream. | |

It is allowable to change the frequency information, or even the entire | |

source alphabet, so long as the decoder can tell from the context of the | |

previously encoded information that it is supposed to do so as well. | |

_fl: The cumulative frequency of all symbols that come before the one to be | |

encoded. | |

_fh: The cumulative frequency of all symbols up to and including the one to | |

be encoded. | |

Together with _fl, this defines the range [_fl,_fh) in which the | |

decoded value will fall. | |

_ft: The sum of the frequencies of all the symbols*/ | |

void ec_encode(ec_enc *_this,unsigned _fl,unsigned _fh,unsigned _ft); | |

/*Equivalent to ec_encode() with _ft==1<<_bits.*/ | |

void ec_encode_bin(ec_enc *_this,unsigned _fl,unsigned _fh,unsigned _bits); | |

/* Encode a bit that has a 1/(1<<_logp) probability of being a one */ | |

void ec_enc_bit_logp(ec_enc *_this,int _val,unsigned _logp); | |

/*Encodes a symbol given an "inverse" CDF table. | |

_s: The index of the symbol to encode. | |

_icdf: The "inverse" CDF, such that symbol _s falls in the range | |

[_s>0?ft-_icdf[_s-1]:0,ft-_icdf[_s]), where ft=1<<_ftb. | |

The values must be monotonically non-increasing, and the last value | |

must be 0. | |

_ftb: The number of bits of precision in the cumulative distribution.*/ | |

void ec_enc_icdf(ec_enc *_this,int _s,const unsigned char *_icdf,unsigned _ftb); | |

/*Encodes a raw unsigned integer in the stream. | |

_fl: The integer to encode. | |

_ft: The number of integers that can be encoded (one more than the max). | |

This must be at least 2, and no more than 2**32-1.*/ | |

void ec_enc_uint(ec_enc *_this,opus_uint32 _fl,opus_uint32 _ft); | |

/*Encodes a sequence of raw bits in the stream. | |

_fl: The bits to encode. | |

_ftb: The number of bits to encode. | |

This must be between 1 and 25, inclusive.*/ | |

void ec_enc_bits(ec_enc *_this,opus_uint32 _fl,unsigned _ftb); | |

/*Overwrites a few bits at the very start of an existing stream, after they | |

have already been encoded. | |

This makes it possible to have a few flags up front, where it is easy for | |

decoders to access them without parsing the whole stream, even if their | |

values are not determined until late in the encoding process, without having | |

to buffer all the intermediate symbols in the encoder. | |

In order for this to work, at least _nbits bits must have already been | |

encoded using probabilities that are an exact power of two. | |

The encoder can verify the number of encoded bits is sufficient, but cannot | |

check this latter condition. | |

_val: The bits to encode (in the least _nbits significant bits). | |

They will be decoded in order from most-significant to least. | |

_nbits: The number of bits to overwrite. | |

This must be no more than 8.*/ | |

void ec_enc_patch_initial_bits(ec_enc *_this,unsigned _val,unsigned _nbits); | |

/*Compacts the data to fit in the target size. | |

This moves up the raw bits at the end of the current buffer so they are at | |

the end of the new buffer size. | |

The caller must ensure that the amount of data that's already been written | |

will fit in the new size. | |

_size: The number of bytes in the new buffer. | |

This must be large enough to contain the bits already written, and | |

must be no larger than the existing size.*/ | |

void ec_enc_shrink(ec_enc *_this,opus_uint32 _size); | |

/*Indicates that there are no more symbols to encode. | |

All reamining output bytes are flushed to the output buffer. | |

ec_enc_init() must be called before the encoder can be used again.*/ | |

void ec_enc_done(ec_enc *_this); | |

#endif |