Go to the documentation of this file.
65 for (
int j = 0; j < 2; j++) {
68 &raw_quant_table[1], 2,
69 &raw_quant_table[0], 2, 1,
94 memset(
c->oldDSCF, 0,
sizeof(
c->oldDSCF));
98 c->bdsp.bswap_buf((uint32_t *) buf, (
const uint32_t *) avctx->
extradata, 4);
112 c->IS,
c->MSS,
c->gapless,
c->lastframelen,
c->maxbands);
113 c->frames_to_skip = 0;
153 case 3:
case 4:
case 5:
case 6:
case 7:
158 case 8:
case 9:
case 10:
case 11:
case 12:
159 case 13:
case 14:
case 15:
case 16:
case 17:
160 t = (1 << (idx - 2)) - 1;
178 int *got_frame_ptr,
AVPacket *avpkt)
180 const uint8_t *buf = avpkt->
data;
187 int off,
ret, last_frame,
skip;
188 int bits_used, bits_avail;
190 memset(
bands, 0,
sizeof(*
bands) * (
c->maxbands + 1));
192 buf_size = avpkt->
size & ~3;
198 if (buf_size != avpkt->
size) {
200 "extra bytes at the end will be skipped.\n");
216 c->bdsp.bswap_buf((uint32_t *)
c->bits, (
const uint32_t *) buf,
223 for(
i = 0;
i <=
c->maxbands;
i++){
224 for(ch = 0; ch < 2; ch++){
240 for(
i = 0;
i <=
mb;
i++)
241 for(ch = 0; ch < 2; ch++)
245 for(
i = 0;
i <=
mb;
i++){
246 for(ch = 0; ch < 2; ch++){
248 bands[
i].scf_idx[ch][2] =
c->oldDSCF[ch][
i];
250 switch(
bands[
i].scfi[ch]){
267 c->oldDSCF[ch][
i] =
bands[
i].scf_idx[ch][2];
272 memset(
c->Q, 0,
sizeof(
c->Q));
275 for(ch = 0; ch < 2; ch++)
280 frame->nb_samples =
c->lastframelen;
283 bits_avail = buf_size * 8;
284 if (!last_frame && ((bits_avail < bits_used) || (bits_used + 32 <= bits_avail))) {
285 av_log(avctx,
AV_LOG_ERROR,
"Error decoding frame: used %i of %i bits\n", bits_used, bits_avail);
288 if(
c->frames_to_skip){
303 memset(
c->oldDSCF, 0,
sizeof(
c->oldDSCF));
304 c->frames_to_skip = 32;
static const uint8_t mpc7_scfi[MPC7_SCFI_SIZE *2]
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
#define AV_LOG_WARNING
Something somehow does not look correct.
static int mpc7_decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame_ptr, AVPacket *avpkt)
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
const FFCodec ff_mpc7_decoder
#define AV_CHANNEL_LAYOUT_STEREO
av_cold void av_lfg_init(AVLFG *c, unsigned int seed)
static const VLCElem * quant_vlc[MPC7_QUANT_VLC_TABLES][2]
static int get_bits_count(const GetBitContext *s)
static VLCElem hdr_vlc[1<< MPC7_HDR_BITS]
av_cold void ff_mpadsp_init(MPADSPContext *s)
This structure describes decoded (raw) audio or video data.
static av_cold int mpc7_decode_close(AVCodecContext *avctx)
int nb_channels
Number of channels in this layout.
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
static const uint8_t mpc7_hdr[MPC7_HDR_SIZE *2]
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
AVCodec p
The public AVCodec.
AVChannelLayout ch_layout
Audio channel layout.
void ff_mpc_dequantize_and_synth(MPCContext *c, int maxband, int16_t **out, int channels)
static int ff_thread_once(char *control, void(*routine)(void))
#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.
For static VLCs, the number of bits can often be hardcoded at each get_vlc2() callsite.
#define FF_CODEC_DECODE_CB(func)
static unsigned int av_lfg_get(AVLFG *c)
Get the next random unsigned 32-bit number using an ALFG.
static const int8_t mpc7_idx32[]
#define LOCAL_ALIGNED_16(t, v,...)
static void mpc7_decode_flush(AVCodecContext *avctx)
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
static const float bands[]
#define CODEC_LONG_NAME(str)
static VLCElem dscf_vlc[1<< MPC7_DSCF_BITS]
av_cold void ff_bswapdsp_init(BswapDSPContext *c)
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
void ff_mpa_synth_init_fixed(void)
static const int8_t mpc7_idx51[]
static const uint8_t mpc7_quant_vlcs[177 *2 *2]
static unsigned int get_bits1(GetBitContext *s)
static av_cold void mpc7_init_static(void)
static av_always_inline int get_vlc2(GetBitContext *s, const VLCElem *table, int bits, int max_depth)
Parse a vlc code.
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
#define MPC7_QUANT_VLC_TABLES
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
int(* init)(AVBSFContext *ctx)
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
An AVChannelLayout holds information about the channel layout of audio data.
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
enum AVSampleFormat sample_fmt
audio sample format
static const uint8_t mpc7_quant_vlc_sizes[MPC7_QUANT_VLC_TABLES]
@ AV_SAMPLE_FMT_S16P
signed 16 bits, planar
static int get_scale_idx(GetBitContext *gb, int ref)
#define i(width, name, range_min, range_max)
static const int8_t mpc7_idx31[]
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
AVSampleFormat
Audio sample formats.
void av_fast_padded_malloc(void *ptr, unsigned int *size, size_t min_size)
Same behaviour av_fast_malloc but the buffer has additional AV_INPUT_BUFFER_PADDING_SIZE at the end w...
static av_cold int mpc7_decode_init(AVCodecContext *avctx)
const char * name
Name of the codec implementation.
static VLCElem scfi_vlc[1<< MPC7_SCFI_BITS]
static const int8_t mpc7_idx30[]
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 const uint8_t mpc7_dscf[MPC7_DSCF_SIZE *2]
main external API structure.
static const int8_t mpc7_idx50[]
Subband structure - hold all variables for each subband.
void av_channel_layout_uninit(AVChannelLayout *channel_layout)
Free any allocated data in the channel layout and reset the channel count to 0.
static int ref[MAX_W *MAX_W]
const av_cold VLCElem * ff_vlc_init_tables_from_lengths(VLCInitState *state, int nb_bits, int nb_codes, const int8_t *lens, int lens_wrap, const void *symbols, int symbols_wrap, int symbols_size, int offset, int flags)
#define avpriv_request_sample(...)
#define VLC_INIT_STATIC_TABLE_FROM_LENGTHS(vlc_table, nb_bits, nb_codes, lens, lens_wrap, syms, syms_wrap, syms_size, offset, flags)
#define VLC_INIT_STATE(_table)
This structure stores compressed data.
static const uint8_t quant_tables[]
static void idx_to_quant(MPCContext *c, GetBitContext *gb, int idx, int *dst)
Fill samples for given subband.
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
static void BS_FUNC() skip(BSCTX *bc, unsigned int n)
Skip n bits in the buffer.
static const int8_t mpc7_quant_vlc_off[MPC7_QUANT_VLC_TABLES]