Go to the documentation of this file.
62 #define ALAC_EXTRADATA_SIZE 36
113 int nb_samples,
int bps,
int rice_history_mult)
117 int sign_modifier = 0;
119 for (
i = 0;
i < nb_samples;
i++) {
127 k =
av_log2((history >> 9) + 3);
132 output_buffer[
i] = (x >> 1) ^ -(x & 1);
138 history += x * rice_history_mult -
139 ((history * rice_history_mult) >> 9);
142 if ((history < 128) && (
i + 1 < nb_samples)) {
146 k = 7 -
av_log2(history) + ((history + 16) >> 6);
150 if (block_size > 0) {
151 if (block_size >= nb_samples -
i) {
153 "invalid zero block size of %d %d %d\n", block_size,
155 block_size = nb_samples -
i - 1;
157 memset(&output_buffer[
i + 1], 0,
158 block_size *
sizeof(*output_buffer));
161 if (block_size <= 0xffff)
175 int nb_samples,
int bps, int16_t *lpc_coefs,
176 int lpc_order,
int lpc_quant)
179 uint32_t *
pred = buffer_out;
182 *buffer_out = *error_buffer;
188 memcpy(&buffer_out[1], &error_buffer[1],
189 (nb_samples - 1) *
sizeof(*buffer_out));
193 if (lpc_order == 31) {
195 for (
i = 1;
i < nb_samples;
i++) {
203 for (
i = 1;
i <= lpc_order &&
i < nb_samples;
i++)
208 for (;
i < nb_samples;
i++) {
211 unsigned error_val = error_buffer[
i];
216 for (j = 0; j < lpc_order; j++)
217 val += (
pred[j] -
d) * lpc_coefs[j];
218 val = (
val + (1LL << (lpc_quant - 1))) >> lpc_quant;
219 val +=
d + error_val;
225 for (j = 0; j < lpc_order && (
int)(error_val * error_sign) > 0; j++) {
229 lpc_coefs[j] -= sign;
230 val *= (unsigned)sign;
231 error_val -= (
val >> lpc_quant) * (j + 1
U);
241 int has_size,
bps, is_compressed, decorr_shift, decorr_left_weight,
ret;
242 uint32_t output_samples;
274 frame->nb_samples = output_samples;
277 }
else if (output_samples != alac->
nb_samples) {
289 int16_t lpc_coefs[2][32];
291 int prediction_type[2];
293 int rice_history_mult[2];
297 "Compression with rice limit 0");
304 if (
channels == 2 && decorr_left_weight && decorr_shift > 31)
310 rice_history_mult[ch] =
get_bits(&alac->
gb, 3);
317 for (
i = lpc_order[ch] - 1;
i >= 0;
i--)
337 if (prediction_type[ch] == 15) {
348 }
else if (prediction_type[ch] > 0) {
350 prediction_type[ch]);
354 bps, lpc_coefs[ch], lpc_order[ch], lpc_quant[ch]);
368 decorr_left_weight = 0;
377 if (decorr_left_weight) {
379 decorr_shift, decorr_left_weight);
394 int16_t *outbuffer = (int16_t *)
frame->extended_data[ch_index + ch];
417 int *got_frame_ptr,
AVPacket *avpkt)
422 int ch,
ret, got_end;
495 for (ch = 0; ch < 2; ch++) {
530 "max samples per frame invalid: %"PRIu32
"\n",
538 alac->
rice_limit = bytestream2_get_byteu(&gb);
539 alac->
channels = bytestream2_get_byteu(&gb);
540 bytestream2_get_be16u(&gb);
541 bytestream2_get_be32u(&gb);
542 bytestream2_get_be32u(&gb);
602 {
"extra_bits_bug",
"Force non-standard decoding process",
#define AV_LOG_WARNING
Something somehow does not look correct.
av_cold void ff_alacdsp_init(ALACDSPContext *c)
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
const FFCodec ff_alac_decoder
static int get_bits_left(GetBitContext *gb)
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
void(* decorrelate_stereo)(int32_t *buffer[2], int nb_samples, int decorr_shift, int decorr_left_weight)
static int get_unary_0_9(GetBitContext *gb)
static void lpc_prediction(int32_t *error_buffer, uint32_t *buffer_out, int nb_samples, int bps, int16_t *lpc_coefs, int lpc_order, int lpc_quant)
int sample_rate
samples per second
static unsigned int decode_scalar(GetBitContext *gb, int k, int bps)
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
static av_always_inline void bytestream2_skipu(GetByteContext *g, unsigned int size)
static int get_bits_count(const GetBitContext *s)
int extra_bits
number of extra bits beyond 16-bit
static av_cold int alac_decode_close(AVCodecContext *avctx)
This structure describes decoded (raw) audio or video data.
@ AV_SAMPLE_FMT_S32P
signed 32 bits, planar
uint8_t rice_history_mult
static int rice_decompress(ALACContext *alac, int32_t *output_buffer, int nb_samples, int bps, int rice_history_mult)
int nb_channels
Number of channels in this layout.
static int sign_only(int v)
static void skip_bits(GetBitContext *s, int n)
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
AVCodec p
The public AVCodec.
AVChannelLayout ch_layout
Audio channel layout.
the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before as well as code calling up to before the decode process starts Call have so the codec calls ff_thread_report set FF_CODEC_CAP_ALLOCATE_PROGRESS in AVCodec caps_internal and use ff_thread_get_buffer() to allocate frames. The frames must then be freed with ff_thread_release_buffer(). Otherwise decode directly into the user-supplied frames. Call ff_thread_report_progress() after some part of the current picture has decoded. A good place to put this is where draw_horiz_band() is called - add this if it isn 't called anywhere
static double val(void *priv, double ch)
static int alac_decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame_ptr, AVPacket *avpkt)
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
#define FF_CODEC_DECODE_CB(func)
int(* init)(AVBSFContext *ctx)
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
static int get_sbits(GetBitContext *s, int n)
int32_t * predict_error_buffer[2]
#define CODEC_LONG_NAME(str)
#define AV_OPT_FLAG_AUDIO_PARAM
static int decode_element(AVCodecContext *avctx, AVFrame *frame, int ch_index, int channels)
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
#define LIBAVUTIL_VERSION_INT
Describe the class of an AVClass context structure.
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
static const AVOption options[]
const char * av_default_item_name(void *ptr)
Return the context name.
static unsigned int get_bits1(GetBitContext *s)
int nb_samples
number of samples in the current frame
uint32_t max_samples_per_frame
uint8_t rice_initial_history
#define AV_CODEC_CAP_CHANNEL_CONF
Codec should fill in channel configuration and samplerate instead of container.
static av_cold int alac_decode_init(AVCodecContext *avctx)
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
enum AVSampleFormat sample_fmt
audio sample format
int32_t * output_samples_buffer[2]
void avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
#define ALAC_MAX_CHANNELS
@ AV_SAMPLE_FMT_S16P
signed 16 bits, planar
#define i(width, name, range_min, range_max)
const uint8_t ff_alac_channel_layout_offsets[ALAC_MAX_CHANNELS][ALAC_MAX_CHANNELS]
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
const AVChannelLayout ff_alac_ch_layouts[ALAC_MAX_CHANNELS+1]
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
static const AVClass alac_class
#define AV_OPT_FLAG_DECODING_PARAM
a generic parameter which can be set by the user for demuxing or decoding
const char * name
Name of the codec implementation.
static const float pred[4]
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
#define AV_INPUT_BUFFER_PADDING_SIZE
main external API structure.
static int allocate_buffers(ALACContext *alac)
void av_channel_layout_uninit(AVChannelLayout *channel_layout)
Free any allocated data in the channel layout and reset the channel count to 0.
static av_const int sign_extend(int val, unsigned bits)
static int alac_set_info(ALACContext *alac)
void(* append_extra_bits[2])(int32_t *buffer[2], int32_t *extra_bits_buffer[2], int extra_bits, int channels, int nb_samples)
int32_t * extra_bits_buffer[2]
#define avpriv_request_sample(...)
This structure stores compressed data.
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
static int get_sbits_long(GetBitContext *s, int n)
Read 0-32 bits as a signed integer.
#define ALAC_EXTRADATA_SIZE