62 #define ALAC_EXTRADATA_SIZE 36 117 int sign_modifier = 0;
127 k =
av_log2((history >> 9) + 3);
132 output_buffer[
i] = (x >> 1) ^ -(x & 1);
138 history += x * rice_history_mult -
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)
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) {
196 buffer_out[
i] =
sign_extend(buffer_out[i - 1] + error_buffer[i],
203 for (i = 1; i <= lpc_order && i <
nb_samples; i++)
204 buffer_out[i] =
sign_extend(buffer_out[i - 1] + error_buffer[i], bps);
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;
278 }
else if (output_samples != alac->
nb_samples) {
290 int16_t lpc_coefs[2][32];
292 int prediction_type[2];
298 "Compression with rice limit 0");
305 if (channels == 2 && decorr_left_weight && decorr_shift > 31)
311 rice_history_mult[ch] =
get_bits(&alac->
gb, 3);
318 for (i = lpc_order[ch] - 1; i >= 0; i--)
338 if (prediction_type[ch] == 15) {
349 }
else if (prediction_type[ch] > 0) {
351 prediction_type[ch]);
355 bps, lpc_coefs[ch], lpc_order[ch], lpc_quant[ch]);
369 decorr_left_weight = 0;
378 if (decorr_left_weight) {
380 decorr_shift, decorr_left_weight);
395 int16_t *outbuffer = (int16_t *)frame->
extended_data[ch_index + ch];
418 int *got_frame_ptr,
AVPacket *avpkt)
424 int ch,
ret, got_end;
443 channels = (element ==
TYPE_CPE) ? 2 : 1;
444 if (ch + channels > alac->
channels ||
497 for (ch = 0; ch < 2; ch++) {
532 "max samples per frame invalid: %"PRIu32
"\n",
540 alac->
rice_limit = bytestream2_get_byteu(&gb);
541 alac->
channels = bytestream2_get_byteu(&gb);
542 bytestream2_get_be16u(&gb);
543 bytestream2_get_be32u(&gb);
544 bytestream2_get_be32u(&gb);
606 {
"extra_bits_bug",
"Force non-standard decoding process",
630 .priv_class = &alac_class
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
int nb_samples
number of samples in the current frame
This structure describes decoded (raw) audio or video data.
#define ALAC_EXTRADATA_SIZE
ptrdiff_t const GLvoid * data
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
#define AV_LOG_WARNING
Something somehow does not look correct.
static int decode_element(AVCodecContext *avctx, AVFrame *frame, int ch_index, int channels)
#define LIBAVUTIL_VERSION_INT
static av_cold int init(AVCodecContext *avctx)
#define avpriv_request_sample(...)
#define AV_OPT_FLAG_AUDIO_PARAM
const char * av_default_item_name(void *ptr)
Return the context name.
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
#define AV_CODEC_CAP_CHANNEL_CONF
Codec should fill in channel configuration and samplerate instead of container.
static const AVOption options[]
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
int32_t * extra_bits_buffer[2]
static int get_sbits(GetBitContext *s, int n)
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
static int get_sbits_long(GetBitContext *s, int n)
Read 0-32 bits as a signed integer.
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
int32_t * predict_error_buffer[2]
static int get_unary_0_9(GetBitContext *gb)
enum AVSampleFormat sample_fmt
audio sample format
uint8_t rice_initial_history
static av_cold int alac_decode_close(AVCodecContext *avctx)
Multithreading support functions.
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
static int get_bits_count(const GetBitContext *s)
static av_always_inline void bytestream2_skipu(GetByteContext *g, unsigned int size)
static const AVClass alac_class
bitstream reader API header.
int32_t * output_samples_buffer[2]
static int alac_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
int extra_bits
number of extra bits beyond 16-bit
static int get_bits_left(GetBitContext *gb)
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
static int sign_only(int v)
const char * name
Name of the codec implementation.
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
uint64_t channel_layout
Audio channel layout.
#define ALAC_MAX_CHANNELS
uint32_t max_samples_per_frame
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
audio channel layout utility functions
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
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
static int alac_set_info(ALACContext *alac)
uint8_t rice_history_mult
const uint64_t ff_alac_channel_layouts[ALAC_MAX_CHANNELS+1]
static const float pred[4]
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Libavcodec external API header.
int sample_rate
samples per second
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
main external API structure.
static unsigned int get_bits1(GetBitContext *s)
Describe the class of an AVClass context structure.
static void skip_bits(GetBitContext *s, int n)
static unsigned int decode_scalar(GetBitContext *gb, int k, int bps)
#define AV_OPT_FLAG_DECODING_PARAM
a generic parameter which can be set by the user for demuxing or decoding
void(* append_extra_bits[2])(int32_t *buffer[2], int32_t *extra_bits_buffer[2], int extra_bits, int channels, int nb_samples)
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
const uint8_t ff_alac_channel_layout_offsets[ALAC_MAX_CHANNELS][ALAC_MAX_CHANNELS]
static av_const int sign_extend(int val, unsigned bits)
void avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
void(* decorrelate_stereo)(int32_t *buffer[2], int nb_samples, int decorr_shift, int decorr_left_weight)
common internal api header.
static av_cold int alac_decode_init(AVCodecContext *avctx)
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
static int allocate_buffers(ALACContext *alac)
int channels
number of audio channels
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)
static int rice_decompress(ALACContext *alac, int32_t *output_buffer, int nb_samples, int bps, int rice_history_mult)
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
uint8_t ** extended_data
pointers to the data planes/channels.
av_cold void ff_alacdsp_init(ALACDSPContext *c)
static double val(void *priv, double ch)
This structure stores compressed data.
int nb_samples
number of audio samples (per channel) described by this frame
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.