[deb_ffmpeg.git] / ffmpeg / libavcodec / atrac3plus.h

/*
 * ATRAC3+ compatible decoder
 *
 * Copyright (c) 2010-2013 Maxim Poliakovski
 *
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * FFmpeg is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

/**
 * @file
 * Global structures, constants and data for ATRAC3+ decoder.
 */

#ifndef AVCODEC_ATRAC3PLUS_H
#define AVCODEC_ATRAC3PLUS_H

#include <stdint.h>

#include "libavutil/float_dsp.h"
#include "atrac.h"
#include "avcodec.h"
#include "fft.h"
#include "get_bits.h"

/** Global unit sizes */
#define ATRAC3P_SUBBANDS        16  ///< number of PQF subbands
#define ATRAC3P_SUBBAND_SAMPLES 128 ///< number of samples per subband
#define ATRAC3P_FRAME_SAMPLES   (ATRAC3P_SUBBAND_SAMPLES * ATRAC3P_SUBBANDS)

#define ATRAC3P_PQF_FIR_LEN     12  ///< length of the prototype FIR of the PQF

/** Global constants */
#define ATRAC3P_POWER_COMP_OFF  15  ///< disable power compensation

/** ATRAC3+ channel unit types */
enum Atrac3pChannelUnitTypes {
    CH_UNIT_MONO       = 0, ///< unit containing one coded channel
    CH_UNIT_STEREO     = 1, ///< unit containing two jointly-coded channels
    CH_UNIT_EXTENSION  = 2, ///< unit containing extension information
    CH_UNIT_TERMINATOR = 3  ///< unit sequence terminator
};

/** Per-channel IPQF history */
typedef struct Atrac3pIPQFChannelCtx {
    DECLARE_ALIGNED(32, float, buf1)[ATRAC3P_PQF_FIR_LEN * 2][8];
    DECLARE_ALIGNED(32, float, buf2)[ATRAC3P_PQF_FIR_LEN * 2][8];
    int pos;
} Atrac3pIPQFChannelCtx;

/** Amplitude envelope of a group of sine waves */
typedef struct Atrac3pWaveEnvelope {
    int has_start_point;    ///< indicates start point within the GHA window
    int has_stop_point;     ///< indicates stop point within the GHA window
    int start_pos;          ///< start position expressed in n*4 samples
    int stop_pos;           ///< stop  position expressed in n*4 samples
} Atrac3pWaveEnvelope;

/** Parameters of a group of sine waves */
typedef struct Atrac3pWavesData {
    Atrac3pWaveEnvelope pend_env;   ///< pending envelope from the previous frame
    Atrac3pWaveEnvelope curr_env;   ///< group envelope from the current frame
    int num_wavs;           ///< number of sine waves in the group
    int start_index;        ///< start index into global tones table for that subband
} Atrac3pWavesData;

/** Parameters of a single sine wave */
typedef struct Atrac3pWaveParam {
    int   freq_index;   ///< wave frequency index
    int   amp_sf;       ///< quantized amplitude scale factor
    int   amp_index;    ///< quantized amplitude index
    int   phase_index;  ///< quantized phase index
} Atrac3pWaveParam;

/** Sound channel parameters */
typedef struct Atrac3pChanParams {
    int ch_num;
    int num_coded_vals;         ///< number of transmitted quant unit values
    int fill_mode;
    int split_point;
    int table_type;             ///< table type: 0 - tone?, 1- noise?
    int qu_wordlen[32];         ///< array of word lengths for each quant unit
    int qu_sf_idx[32];          ///< array of scale factor indexes for each quant unit
    int qu_tab_idx[32];         ///< array of code table indexes for each quant unit
    int16_t spectrum[2048];     ///< decoded IMDCT spectrum
    uint8_t power_levs[5];      ///< power compensation levels

    /* imdct window shape history (2 frames) for overlapping. */
    uint8_t wnd_shape_hist[2][ATRAC3P_SUBBANDS];    ///< IMDCT window shape, 0=sine/1=steep
    uint8_t *wnd_shape;         ///< IMDCT window shape for current frame
    uint8_t *wnd_shape_prev;    ///< IMDCT window shape for previous frame

    /* gain control data history (2 frames) for overlapping. */
    AtracGainInfo gain_data_hist[2][ATRAC3P_SUBBANDS];  ///< gain control data for all subbands
    AtracGainInfo *gain_data;       ///< gain control data for next frame
    AtracGainInfo *gain_data_prev;  ///< gain control data for previous frame
    int num_gain_subbands;      ///< number of subbands with gain control data

    /* tones data history (2 frames) for overlapping. */
    Atrac3pWavesData tones_info_hist[2][ATRAC3P_SUBBANDS];
    Atrac3pWavesData *tones_info;
    Atrac3pWavesData *tones_info_prev;
} Atrac3pChanParams;

/* Per-unit sine wave parameters */
typedef struct Atrac3pWaveSynthParams {
    int tones_present;                      ///< 1 - tones info present
    int amplitude_mode;                     ///< 1 - low range, 0 - high range
    int num_tone_bands;                     ///< number of PQF bands with tones
    uint8_t tone_sharing[ATRAC3P_SUBBANDS]; ///< 1 - subband-wise tone sharing flags
    uint8_t tone_master[ATRAC3P_SUBBANDS];  ///< 1 - subband-wise tone channel swapping
    uint8_t phase_shift[ATRAC3P_SUBBANDS];  ///< 1 - subband-wise 180° phase shifting
    int tones_index;                        ///< total sum of tones in this unit
    Atrac3pWaveParam waves[48];
} Atrac3pWaveSynthParams;

/** Channel unit parameters */
typedef struct Atrac3pChanUnitCtx {
    /* channel unit variables */
    int unit_type;                          ///< unit type (mono/stereo)
    int num_quant_units;
    int num_subbands;
    int used_quant_units;                   ///< number of quant units with coded spectrum
    int num_coded_subbands;                 ///< number of subbands with coded spectrum
    int mute_flag;                          ///< mute flag
    int use_full_table;                     ///< 1 - full table list, 0 - restricted one
    int noise_present;                      ///< 1 - global noise info present
    int noise_level_index;                  ///< global noise level index
    int noise_table_index;                  ///< global noise RNG table index
    uint8_t swap_channels[ATRAC3P_SUBBANDS];    ///< 1 - perform subband-wise channel swapping
    uint8_t negate_coeffs[ATRAC3P_SUBBANDS];    ///< 1 - subband-wise IMDCT coefficients negation
    Atrac3pChanParams channels[2];

    /* Variables related to GHA tones */
    Atrac3pWaveSynthParams wave_synth_hist[2];     ///< waves synth history for two frames
    Atrac3pWaveSynthParams *waves_info;
    Atrac3pWaveSynthParams *waves_info_prev;

    Atrac3pIPQFChannelCtx ipqf_ctx[2];
    DECLARE_ALIGNED(32, float, prev_buf)[2][ATRAC3P_FRAME_SAMPLES]; ///< overlapping buffer
} Atrac3pChanUnitCtx;

/**
 * Initialize VLC tables for bitstream parsing.
 */
void ff_atrac3p_init_vlcs(void);

/**
 * Decode bitstream data of a channel unit.
 *
 * @param[in]     gb            the GetBit context
 * @param[in,out] ctx           ptr to the channel unit context
 * @param[in]     num_channels  number of channels to process
 * @param[in]     avctx         ptr to the AVCodecContext
 * @return result code: 0 = OK, otherwise - error code
 */
int ff_atrac3p_decode_channel_unit(GetBitContext *gb, Atrac3pChanUnitCtx *ctx,
                                   int num_channels, AVCodecContext *avctx);

/**
 * Initialize IMDCT transform.
 *
 * @param[in]   avctx      ptr to the AVCodecContext
 * @param[in]   mdct_ctx   pointer to MDCT transform context
 */
void ff_atrac3p_init_imdct(AVCodecContext *avctx, FFTContext *mdct_ctx);

/**
 * Initialize sine waves synthesizer.
 */
void ff_atrac3p_init_wave_synth(void);

/**
 * Synthesize sine waves for a particular subband.
 *
 * @param[in]   ch_unit   pointer to the channel unit context
 * @param[in]   fdsp      pointer to float DSP context
 * @param[in]   ch_num    which channel to process
 * @param[in]   sb        which subband to process
 * @param[out]  out       receives processed data
 */
void ff_atrac3p_generate_tones(Atrac3pChanUnitCtx *ch_unit, AVFloatDSPContext *fdsp,
                               int ch_num, int sb, float *out);

/**
 * Perform power compensation aka noise dithering.
 *
 * @param[in]      ctx         ptr to the channel context
 * @param[in]      ch_index    which channel to process
 * @param[in,out]  sp          ptr to channel spectrum to process
 * @param[in]      rng_index   indicates which RNG table to use
 * @param[in]      sb_num      which subband to process
 */
void ff_atrac3p_power_compensation(Atrac3pChanUnitCtx *ctx, int ch_index,
                                   float *sp, int rng_index, int sb_num);

/**
 * Regular IMDCT and windowing without overlapping,
 * with spectrum reversal in the odd subbands.
 *
 * @param[in]   fdsp       pointer to float DSP context
 * @param[in]   mdct_ctx   pointer to MDCT transform context
 * @param[in]   pIn        float input
 * @param[out]  pOut       float output
 * @param[in]   wind_id    which MDCT window to apply
 * @param[in]   sb         subband number
 */
void ff_atrac3p_imdct(AVFloatDSPContext *fdsp, FFTContext *mdct_ctx, float *pIn,
                      float *pOut, int wind_id, int sb);

/**
 * Subband synthesis filter based on the polyphase quadrature (pseudo-QMF)
 * filter bank.
 *
 * @param[in]      dct_ctx   ptr to the pre-initialized IDCT context
 * @param[in,out]  hist      ptr to the filter history
 * @param[in]      in        input data to process
 * @param[out]     out       receives processed data
 */
void ff_atrac3p_ipqf(FFTContext *dct_ctx, Atrac3pIPQFChannelCtx *hist,
                     const float *in, float *out);

extern const uint16_t ff_atrac3p_qu_to_spec_pos[33];
extern const float ff_atrac3p_sf_tab[64];
extern const float ff_atrac3p_mant_tab[8];

#endif /* AVCODEC_ATRAC3PLUS_H */
Commit	Line	Data
2ba45a60 DM	1	/*
	2	* ATRAC3+ compatible decoder
	3	*
	4	* Copyright (c) 2010-2013 Maxim Poliakovski
	5	*
	6	* This file is part of FFmpeg.
	7	*
	8	* FFmpeg is free software; you can redistribute it and/or
	9	* modify it under the terms of the GNU Lesser General Public
	10	* License as published by the Free Software Foundation; either
	11	* version 2.1 of the License, or (at your option) any later version.
	12	*
	13	* FFmpeg is distributed in the hope that it will be useful,
	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	16	* Lesser General Public License for more details.
	17	*
	18	* You should have received a copy of the GNU Lesser General Public
	19	* License along with FFmpeg; if not, write to the Free Software
	20	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
	21	*/
	22
	23	/**
	24	* @file
	25	* Global structures, constants and data for ATRAC3+ decoder.
	26	*/
	27
	28	#ifndef AVCODEC_ATRAC3PLUS_H
	29	#define AVCODEC_ATRAC3PLUS_H
	30
	31	#include <stdint.h>
	32
	33	#include "libavutil/float_dsp.h"
	34	#include "atrac.h"
	35	#include "avcodec.h"
	36	#include "fft.h"
	37	#include "get_bits.h"
	38
	39	/** Global unit sizes */
	40	#define ATRAC3P_SUBBANDS 16 ///< number of PQF subbands
	41	#define ATRAC3P_SUBBAND_SAMPLES 128 ///< number of samples per subband
	42	#define ATRAC3P_FRAME_SAMPLES (ATRAC3P_SUBBAND_SAMPLES * ATRAC3P_SUBBANDS)
	43
	44	#define ATRAC3P_PQF_FIR_LEN 12 ///< length of the prototype FIR of the PQF
	45
	46	/** Global constants */
	47	#define ATRAC3P_POWER_COMP_OFF 15 ///< disable power compensation
	48
	49	/** ATRAC3+ channel unit types */
	50	enum Atrac3pChannelUnitTypes {
	51	CH_UNIT_MONO = 0, ///< unit containing one coded channel
	52	CH_UNIT_STEREO = 1, ///< unit containing two jointly-coded channels
	53	CH_UNIT_EXTENSION = 2, ///< unit containing extension information
	54	CH_UNIT_TERMINATOR = 3 ///< unit sequence terminator
	55	};
	56
	57	/** Per-channel IPQF history */
	58	typedef struct Atrac3pIPQFChannelCtx {
	59	DECLARE_ALIGNED(32, float, buf1)[ATRAC3P_PQF_FIR_LEN * 2][8];
	60	DECLARE_ALIGNED(32, float, buf2)[ATRAC3P_PQF_FIR_LEN * 2][8];
	61	int pos;
	62	} Atrac3pIPQFChannelCtx;
	63
	64	/** Amplitude envelope of a group of sine waves */
65	typedef struct Atrac3pWaveEnvelope {
66	int has_start_point; ///< indicates start point within the GHA window
67	int has_stop_point; ///< indicates stop point within the GHA window
68	int start_pos; ///< start position expressed in n*4 samples
69	int stop_pos; ///< stop position expressed in n*4 samples
70	} Atrac3pWaveEnvelope;
71
72	/** Parameters of a group of sine waves */
73	typedef struct Atrac3pWavesData {
74	Atrac3pWaveEnvelope pend_env; ///< pending envelope from the previous frame
75	Atrac3pWaveEnvelope curr_env; ///< group envelope from the current frame
76	int num_wavs; ///< number of sine waves in the group
77	int start_index; ///< start index into global tones table for that subband
78	} Atrac3pWavesData;
79
80	/** Parameters of a single sine wave */
81	typedef struct Atrac3pWaveParam {
82	int freq_index; ///< wave frequency index
83	int amp_sf; ///< quantized amplitude scale factor
84	int amp_index; ///< quantized amplitude index
85	int phase_index; ///< quantized phase index
86	} Atrac3pWaveParam;
87
88	/** Sound channel parameters */
89	typedef struct Atrac3pChanParams {
90	int ch_num;
91	int num_coded_vals; ///< number of transmitted quant unit values
92	int fill_mode;
93	int split_point;
94	int table_type; ///< table type: 0 - tone?, 1- noise?
95	int qu_wordlen[32]; ///< array of word lengths for each quant unit
96	int qu_sf_idx[32]; ///< array of scale factor indexes for each quant unit
97	int qu_tab_idx[32]; ///< array of code table indexes for each quant unit
98	int16_t spectrum[2048]; ///< decoded IMDCT spectrum
99	uint8_t power_levs[5]; ///< power compensation levels
100
101	/* imdct window shape history (2 frames) for overlapping. */
102	uint8_t wnd_shape_hist[2][ATRAC3P_SUBBANDS]; ///< IMDCT window shape, 0=sine/1=steep
103	uint8_t *wnd_shape; ///< IMDCT window shape for current frame
104	uint8_t *wnd_shape_prev; ///< IMDCT window shape for previous frame
105
106	/* gain control data history (2 frames) for overlapping. */
107	AtracGainInfo gain_data_hist[2][ATRAC3P_SUBBANDS]; ///< gain control data for all subbands
108	AtracGainInfo *gain_data; ///< gain control data for next frame
109	AtracGainInfo *gain_data_prev; ///< gain control data for previous frame
110	int num_gain_subbands; ///< number of subbands with gain control data
111
112	/* tones data history (2 frames) for overlapping. */
113	Atrac3pWavesData tones_info_hist[2][ATRAC3P_SUBBANDS];
114	Atrac3pWavesData *tones_info;
115	Atrac3pWavesData *tones_info_prev;
116	} Atrac3pChanParams;
117
118	/* Per-unit sine wave parameters */
119	typedef struct Atrac3pWaveSynthParams {
120	int tones_present; ///< 1 - tones info present
121	int amplitude_mode; ///< 1 - low range, 0 - high range
122	int num_tone_bands; ///< number of PQF bands with tones
123	uint8_t tone_sharing[ATRAC3P_SUBBANDS]; ///< 1 - subband-wise tone sharing flags
124	uint8_t tone_master[ATRAC3P_SUBBANDS]; ///< 1 - subband-wise tone channel swapping
125	uint8_t phase_shift[ATRAC3P_SUBBANDS]; ///< 1 - subband-wise 180° phase shifting
126	int tones_index; ///< total sum of tones in this unit
127	Atrac3pWaveParam waves[48];
128	} Atrac3pWaveSynthParams;
129
130	/** Channel unit parameters */
131	typedef struct Atrac3pChanUnitCtx {
132	/* channel unit variables */
133	int unit_type; ///< unit type (mono/stereo)
134	int num_quant_units;
135	int num_subbands;
136	int used_quant_units; ///< number of quant units with coded spectrum
137	int num_coded_subbands; ///< number of subbands with coded spectrum
138	int mute_flag; ///< mute flag
139	int use_full_table; ///< 1 - full table list, 0 - restricted one
140	int noise_present; ///< 1 - global noise info present
141	int noise_level_index; ///< global noise level index
142	int noise_table_index; ///< global noise RNG table index
143	uint8_t swap_channels[ATRAC3P_SUBBANDS]; ///< 1 - perform subband-wise channel swapping
144	uint8_t negate_coeffs[ATRAC3P_SUBBANDS]; ///< 1 - subband-wise IMDCT coefficients negation
145	Atrac3pChanParams channels[2];
146
147	/* Variables related to GHA tones */
148	Atrac3pWaveSynthParams wave_synth_hist[2]; ///< waves synth history for two frames
149	Atrac3pWaveSynthParams *waves_info;
150	Atrac3pWaveSynthParams *waves_info_prev;
151
152	Atrac3pIPQFChannelCtx ipqf_ctx[2];
153	DECLARE_ALIGNED(32, float, prev_buf)[2][ATRAC3P_FRAME_SAMPLES]; ///< overlapping buffer
154	} Atrac3pChanUnitCtx;
155
156	/**
157	* Initialize VLC tables for bitstream parsing.
158	*/
159	void ff_atrac3p_init_vlcs(void);
160
161	/**
162	* Decode bitstream data of a channel unit.
163	*
164	* @param[in] gb the GetBit context
165	* @param[in,out] ctx ptr to the channel unit context
166	* @param[in] num_channels number of channels to process
167	* @param[in] avctx ptr to the AVCodecContext
168	* @return result code: 0 = OK, otherwise - error code
169	*/
170	int ff_atrac3p_decode_channel_unit(GetBitContext gb, Atrac3pChanUnitCtx ctx,
171	int num_channels, AVCodecContext *avctx);
172
173	/**
174	* Initialize IMDCT transform.
175	*
176	* @param[in] avctx ptr to the AVCodecContext
177	* @param[in] mdct_ctx pointer to MDCT transform context
178	*/
179	void ff_atrac3p_init_imdct(AVCodecContext avctx, FFTContext mdct_ctx);
180
181	/**
182	* Initialize sine waves synthesizer.
183	*/
184	void ff_atrac3p_init_wave_synth(void);
185
186	/**
187	* Synthesize sine waves for a particular subband.
188	*
189	* @param[in] ch_unit pointer to the channel unit context
190	* @param[in] fdsp pointer to float DSP context
191	* @param[in] ch_num which channel to process
192	* @param[in] sb which subband to process
193	* @param[out] out receives processed data
194	*/
195	void ff_atrac3p_generate_tones(Atrac3pChanUnitCtx ch_unit, AVFloatDSPContext fdsp,
196	int ch_num, int sb, float *out);
197
198	/**
199	* Perform power compensation aka noise dithering.
200	*
201	* @param[in] ctx ptr to the channel context
202	* @param[in] ch_index which channel to process
203	* @param[in,out] sp ptr to channel spectrum to process
204	* @param[in] rng_index indicates which RNG table to use
205	* @param[in] sb_num which subband to process
206	*/
207	void ff_atrac3p_power_compensation(Atrac3pChanUnitCtx *ctx, int ch_index,
208	float *sp, int rng_index, int sb_num);
209
210	/**
211	* Regular IMDCT and windowing without overlapping,
212	* with spectrum reversal in the odd subbands.
213	*
214	* @param[in] fdsp pointer to float DSP context
215	* @param[in] mdct_ctx pointer to MDCT transform context
216	* @param[in] pIn float input
217	* @param[out] pOut float output
218	* @param[in] wind_id which MDCT window to apply
219	* @param[in] sb subband number
220	*/
221	void ff_atrac3p_imdct(AVFloatDSPContext fdsp, FFTContext mdct_ctx, float *pIn,
222	float *pOut, int wind_id, int sb);
223
224	/**
225	* Subband synthesis filter based on the polyphase quadrature (pseudo-QMF)
226	* filter bank.
227	*
228	* @param[in] dct_ctx ptr to the pre-initialized IDCT context
229	* @param[in,out] hist ptr to the filter history
230	* @param[in] in input data to process
231	* @param[out] out receives processed data
232	*/
233	void ff_atrac3p_ipqf(FFTContext dct_ctx, Atrac3pIPQFChannelCtx hist,
234	const float in, float out);
235
236	extern const uint16_t ff_atrac3p_qu_to_spec_pos[33];
237	extern const float ff_atrac3p_sf_tab[64];
238	extern const float ff_atrac3p_mant_tab[8];
239
240	#endif /* AVCODEC_ATRAC3PLUS_H */