* Copyright (c) 2006-2008 Maxim Poliakovski
* Copyright (c) 2006-2008 Benjamin Larsson
*
- * This file is part of Libav.
+ * This file is part of FFmpeg.
*
- * Libav is free software; you can redistribute it and/or
+ * 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.
*
- * Libav is distributed in the hope that it will be useful,
+ * 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 Libav; if not, write to the Free Software
+ * License along with FFmpeg; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include <stdio.h>
#include "libavutil/float_dsp.h"
+#include "libavutil/libm.h"
#include "avcodec.h"
- #include "get_bits.h"
#include "bytestream.h"
#include "fft.h"
#include "fmtconvert.h"
+ #include "get_bits.h"
#include "atrac.h"
#include "atrac3data.h"
#define SAMPLES_PER_FRAME 1024
#define MDCT_SIZE 512
- /* These structures are needed to store the parsed gain control data. */
- typedef struct {
- int num_gain_data;
- int levcode[8];
- int loccode[8];
- } gain_info;
-
- typedef struct {
- gain_info gBlock[4];
- } gain_block;
-
- typedef struct {
- int pos;
- int numCoefs;
- float coef[8];
- } tonal_component;
-
- typedef struct {
- int bandsCoded;
- int numComponents;
- tonal_component components[64];
- float prevFrame[SAMPLES_PER_FRAME];
- int gcBlkSwitch;
- gain_block gainBlock[2];
+ typedef struct GainInfo {
+ int num_gain_data;
+ int lev_code[8];
+ int loc_code[8];
+ } GainInfo;
+
+ typedef struct GainBlock {
+ GainInfo g_block[4];
+ } GainBlock;
+
+ typedef struct TonalComponent {
+ int pos;
+ int num_coefs;
+ float coef[8];
+ } TonalComponent;
+
+ typedef struct ChannelUnit {
+ int bands_coded;
+ int num_components;
+ float prev_frame[SAMPLES_PER_FRAME];
+ int gc_blk_switch;
+ TonalComponent components[64];
+ GainBlock gain_block[2];
DECLARE_ALIGNED(32, float, spectrum)[SAMPLES_PER_FRAME];
- DECLARE_ALIGNED(32, float, IMDCT_buf)[SAMPLES_PER_FRAME];
+ DECLARE_ALIGNED(32, float, imdct_buf)[SAMPLES_PER_FRAME];
- float delayBuf1[46]; ///<qmf delay buffers
- float delayBuf2[46];
- float delayBuf3[46];
- } channel_unit;
+ float delay_buf1[46]; ///<qmf delay buffers
+ float delay_buf2[46];
+ float delay_buf3[46];
+ } ChannelUnit;
- typedef struct {
- AVFrame frame;
- GetBitContext gb;
+ typedef struct ATRAC3Context {
+ AVFrame frame;
+ GetBitContext gb;
//@{
/** stream data */
- int channels;
- int codingMode;
- int bit_rate;
- int sample_rate;
- int samples_per_channel;
- int samples_per_frame;
-
- int bits_per_frame;
- int bytes_per_frame;
- int pBs;
- channel_unit* pUnits;
+ int coding_mode;
+ int bit_rate;
+ int sample_rate;
+ int samples_per_channel;
+ int samples_per_frame;
+
+ int bits_per_frame;
+ int bytes_per_frame;
+ ChannelUnit *units;
//@}
//@{
/** joint-stereo related variables */
- int matrix_coeff_index_prev[4];
- int matrix_coeff_index_now[4];
- int matrix_coeff_index_next[4];
- int weighting_delay[6];
+ int matrix_coeff_index_prev[4];
+ int matrix_coeff_index_now[4];
+ int matrix_coeff_index_next[4];
+ int weighting_delay[6];
//@}
//@{
/** data buffers */
- uint8_t* decoded_bytes_buffer;
- float tempBuf[1070];
+ uint8_t *decoded_bytes_buffer;
+ float temp_buf[1070];
//@}
//@{
/** extradata */
- int atrac3version;
- int delay;
- int scrambled_stream;
- int frame_factor;
+ int version;
+ int delay;
+ int scrambled_stream;
+ int frame_factor;
//@}
- FFTContext mdct_ctx;
- FmtConvertContext fmt_conv;
- AVFloatDSPContext fdsp;
+ FFTContext mdct_ctx;
+ FmtConvertContext fmt_conv;
+ AVFloatDSPContext fdsp;
} ATRAC3Context;
static DECLARE_ALIGNED(32, float, mdct_window)[MDCT_SIZE];
- static VLC spectral_coeff_tab[7];
- static float gain_tab1[16];
- static float gain_tab2[31];
+ static VLC spectral_coeff_tab[7];
+ static float gain_tab1[16];
+ static float gain_tab2[31];
- /**
- * Regular 512 points IMDCT without overlapping, with the exception of the swapping of odd bands
- * caused by the reverse spectra of the QMF.
+ /*
+ * Regular 512 points IMDCT without overlapping, with the exception of the
+ * swapping of odd bands caused by the reverse spectra of the QMF.
*
- * @param pInput float input
- * @param pOutput float output
* @param odd_band 1 if the band is an odd band
*/
-
- static void IMLT(ATRAC3Context *q, float *pInput, float *pOutput, int odd_band)
+ static void imlt(ATRAC3Context *q, float *input, float *output, int odd_band)
{
- int i;
+ int i;
if (odd_band) {
/**
- * Reverse the odd bands before IMDCT, this is an effect of the QMF transform
- * or it gives better compression to do it this way.
- * FIXME: It should be possible to handle this in imdct_calc
- * for that to happen a modification of the prerotation step of
- * all SIMD code and C code is needed.
- * Or fix the functions before so they generate a pre reversed spectrum.
- */
-
- for (i=0; i<128; i++)
- FFSWAP(float, pInput[i], pInput[255-i]);
+ * Reverse the odd bands before IMDCT, this is an effect of the QMF
+ * transform or it gives better compression to do it this way.
+ * FIXME: It should be possible to handle this in imdct_calc
+ * for that to happen a modification of the prerotation step of
+ * all SIMD code and C code is needed.
+ * Or fix the functions before so they generate a pre reversed spectrum.
+ */
+ for (i = 0; i < 128; i++)
+ FFSWAP(float, input[i], input[255 - i]);
}
- q->mdct_ctx.imdct_calc(&q->mdct_ctx,pOutput,pInput);
+ q->mdct_ctx.imdct_calc(&q->mdct_ctx, output, input);
/* Perform windowing on the output. */
- q->fdsp.vector_fmul(pOutput, pOutput, mdct_window, MDCT_SIZE);
-
+ q->fdsp.vector_fmul(output, output, mdct_window, MDCT_SIZE);
}
-
- /**
- * Atrac 3 indata descrambling, only used for data coming from the rm container
- *
- * @param inbuffer pointer to 8 bit array of indata
- * @param out pointer to 8 bit array of outdata
- * @param bytes amount of bytes
+ /*
+ * indata descrambling, only used for data coming from the rm container
*/
-
- static int decode_bytes(const uint8_t* inbuffer, uint8_t* out, int bytes){
+ static int decode_bytes(const uint8_t *input, uint8_t *out, int bytes)
+ {
int i, off;
uint32_t c;
- const uint32_t* buf;
- uint32_t* obuf = (uint32_t*) out;
+ const uint32_t *buf;
+ uint32_t *output = (uint32_t *)out;
- off = (intptr_t)inbuffer & 3;
- buf = (const uint32_t*) (inbuffer - off);
- c = av_be2ne32((0x537F6103 >> (off*8)) | (0x537F6103 << (32-(off*8))));
+ off = (intptr_t)input & 3;
+ buf = (const uint32_t *)(input - off);
+ c = av_be2ne32((0x537F6103 >> (off * 8)) | (0x537F6103 << (32 - (off * 8))));
bytes += 3 + off;
- for (i = 0; i < bytes/4; i++)
- obuf[i] = c ^ buf[i];
+ for (i = 0; i < bytes / 4; i++)
+ output[i] = c ^ buf[i];
if (off)
av_log_ask_for_sample(NULL, "Offset of %d not handled.\n", off);
return off;
}
-
- static av_cold int init_atrac3_transforms(ATRAC3Context *q) {
+ static av_cold int init_atrac3_transforms(ATRAC3Context *q)
+ {
float enc_window[256];
int i;
- /* Generate the mdct window, for details see
+ /* generate the mdct window, for details see
* http://wiki.multimedia.cx/index.php?title=RealAudio_atrc#Windows */
- for (i=0 ; i<256; i++)
+ for (i = 0; i < 256; i++)
enc_window[i] = (sin(((i + 0.5) / 256.0 - 0.5) * M_PI) + 1.0) * 0.5;
- if (!mdct_window[0])
- for (i=0 ; i<256; i++) {
- mdct_window[i] = enc_window[i]/(enc_window[i]*enc_window[i] + enc_window[255-i]*enc_window[255-i]);
- mdct_window[511-i] = mdct_window[i];
+ if (!mdct_window[0]) {
+ for (i = 0; i < 256; i++) {
+ mdct_window[i] = enc_window[i] /
+ (enc_window[ i] * enc_window[ i] +
+ enc_window[255 - i] * enc_window[255 - i]);
+ mdct_window[511 - i] = mdct_window[i];
}
+ }
- /* Initialize the MDCT transform. */
+ /* initialize the MDCT transform */
return ff_mdct_init(&q->mdct_ctx, 9, 1, 1.0 / 32768);
}
- /**
- * Atrac3 uninit, free all allocated memory
- */
-
static av_cold int atrac3_decode_close(AVCodecContext *avctx)
{
ATRAC3Context *q = avctx->priv_data;
- av_free(q->pUnits);
+ av_free(q->units);
av_free(q->decoded_bytes_buffer);
ff_mdct_end(&q->mdct_ctx);
return 0;
}
- /**
- / * Mantissa decoding
+ /*
+ * Mantissa decoding
*
- * @param gb the GetBit context
- * @param selector what table is the output values coded with
- * @param codingFlag constant length coding or variable length coding
- * @param mantissas mantissa output table
- * @param numCodes amount of values to get
+ * @param selector which table the output values are coded with
+ * @param coding_flag constant length coding or variable length coding
+ * @param mantissas mantissa output table
+ * @param num_codes number of values to get
*/
-
- static void readQuantSpectralCoeffs (GetBitContext *gb, int selector, int codingFlag, int* mantissas, int numCodes)
+ static void read_quant_spectral_coeffs(GetBitContext *gb, int selector,
+ int coding_flag, int *mantissas,
+ int num_codes)
{
- int numBits, cnt, code, huffSymb;
+ int i, code, huff_symb;
if (selector == 1)
- numCodes /= 2;
+ num_codes /= 2;
- if (codingFlag != 0) {
+ if (coding_flag != 0) {
/* constant length coding (CLC) */
- numBits = CLCLengthTab[selector];
+ int num_bits = clc_length_tab[selector];
if (selector > 1) {
- for (cnt = 0; cnt < numCodes; cnt++) {
- if (numBits)
- code = get_sbits(gb, numBits);
+ for (i = 0; i < num_codes; i++) {
+ if (num_bits)
+ code = get_sbits(gb, num_bits);
else
code = 0;
- mantissas[cnt] = code;
+ mantissas[i] = code;
}
} else {
- for (cnt = 0; cnt < numCodes; cnt++) {
- if (numBits)
- code = get_bits(gb, numBits); //numBits is always 4 in this case
+ for (i = 0; i < num_codes; i++) {
+ if (num_bits)
+ code = get_bits(gb, num_bits); // num_bits is always 4 in this case
else
code = 0;
- mantissas[cnt*2] = seTab_0[code >> 2];
- mantissas[cnt*2+1] = seTab_0[code & 3];
+ mantissas[i * 2 ] = mantissa_clc_tab[code >> 2];
+ mantissas[i * 2 + 1] = mantissa_clc_tab[code & 3];
}
}
} else {
/* variable length coding (VLC) */
if (selector != 1) {
- for (cnt = 0; cnt < numCodes; cnt++) {
- huffSymb = get_vlc2(gb, spectral_coeff_tab[selector-1].table, spectral_coeff_tab[selector-1].bits, 3);
- huffSymb += 1;
- code = huffSymb >> 1;
- if (huffSymb & 1)
+ for (i = 0; i < num_codes; i++) {
+ huff_symb = get_vlc2(gb, spectral_coeff_tab[selector-1].table,
+ spectral_coeff_tab[selector-1].bits, 3);
+ huff_symb += 1;
+ code = huff_symb >> 1;
+ if (huff_symb & 1)
code = -code;
- mantissas[cnt] = code;
+ mantissas[i] = code;
}
} else {
- for (cnt = 0; cnt < numCodes; cnt++) {
- huffSymb = get_vlc2(gb, spectral_coeff_tab[selector-1].table, spectral_coeff_tab[selector-1].bits, 3);
- mantissas[cnt*2] = decTable1[huffSymb*2];
- mantissas[cnt*2+1] = decTable1[huffSymb*2+1];
+ for (i = 0; i < num_codes; i++) {
+ huff_symb = get_vlc2(gb, spectral_coeff_tab[selector - 1].table,
+ spectral_coeff_tab[selector - 1].bits, 3);
+ mantissas[i * 2 ] = mantissa_vlc_tab[huff_symb * 2 ];
+ mantissas[i * 2 + 1] = mantissa_vlc_tab[huff_symb * 2 + 1];
}
}
}
}
- /**
+ /*
* Restore the quantized band spectrum coefficients
*
- * @param gb the GetBit context
- * @param pOut decoded band spectrum
- * @return outSubbands subband counter, fix for broken specification/files
+ * @return subband count, fix for broken specification/files
*/
-
- static int decodeSpectrum (GetBitContext *gb, float *pOut)
+ static int decode_spectrum(GetBitContext *gb, float *output)
{
- int numSubbands, codingMode, cnt, first, last, subbWidth, *pIn;
- int subband_vlc_index[32], SF_idxs[32];
- int mantissas[128];
- float SF;
-
- numSubbands = get_bits(gb, 5); // number of coded subbands
- codingMode = get_bits1(gb); // coding Mode: 0 - VLC/ 1-CLC
-
- /* Get the VLC selector table for the subbands, 0 means not coded. */
- for (cnt = 0; cnt <= numSubbands; cnt++)
- subband_vlc_index[cnt] = get_bits(gb, 3);
-
- /* Read the scale factor indexes from the stream. */
- for (cnt = 0; cnt <= numSubbands; cnt++) {
- if (subband_vlc_index[cnt] != 0)
- SF_idxs[cnt] = get_bits(gb, 6);
+ int num_subbands, coding_mode, i, j, first, last, subband_size;
+ int subband_vlc_index[32], sf_index[32];
+ int mantissas[128];
+ float scale_factor;
+
+ num_subbands = get_bits(gb, 5); // number of coded subbands
+ coding_mode = get_bits1(gb); // coding Mode: 0 - VLC/ 1-CLC
+
+ /* get the VLC selector table for the subbands, 0 means not coded */
+ for (i = 0; i <= num_subbands; i++)
+ subband_vlc_index[i] = get_bits(gb, 3);
+
+ /* read the scale factor indexes from the stream */
+ for (i = 0; i <= num_subbands; i++) {
+ if (subband_vlc_index[i] != 0)
+ sf_index[i] = get_bits(gb, 6);
}
- for (cnt = 0; cnt <= numSubbands; cnt++) {
- first = subbandTab[cnt];
- last = subbandTab[cnt+1];
+ for (i = 0; i <= num_subbands; i++) {
+ first = subband_tab[i ];
+ last = subband_tab[i + 1];
- subbWidth = last - first;
+ subband_size = last - first;
- if (subband_vlc_index[cnt] != 0) {
- /* Decode spectral coefficients for this subband. */
+ if (subband_vlc_index[i] != 0) {
+ /* decode spectral coefficients for this subband */
/* TODO: This can be done faster is several blocks share the
* same VLC selector (subband_vlc_index) */
- readQuantSpectralCoeffs (gb, subband_vlc_index[cnt], codingMode, mantissas, subbWidth);
+ read_quant_spectral_coeffs(gb, subband_vlc_index[i], coding_mode,
+ mantissas, subband_size);
- /* Decode the scale factor for this subband. */
- SF = ff_atrac_sf_table[SF_idxs[cnt]] * iMaxQuant[subband_vlc_index[cnt]];
+ /* decode the scale factor for this subband */
+ scale_factor = ff_atrac_sf_table[sf_index[i]] *
+ inv_max_quant[subband_vlc_index[i]];
- /* Inverse quantize the coefficients. */
- for (pIn=mantissas ; first<last; first++, pIn++)
- pOut[first] = *pIn * SF;
+ /* inverse quantize the coefficients */
+ for (j = 0; first < last; first++, j++)
+ output[first] = mantissas[j] * scale_factor;
} else {
- /* This subband was not coded, so zero the entire subband. */
- memset(pOut+first, 0, subbWidth*sizeof(float));
+ /* this subband was not coded, so zero the entire subband */
+ memset(output + first, 0, subband_size * sizeof(float));
}
}
- /* Clear the subbands that were not coded. */
- first = subbandTab[cnt];
- memset(pOut+first, 0, (SAMPLES_PER_FRAME - first) * sizeof(float));
- return numSubbands;
+ /* clear the subbands that were not coded */
+ first = subband_tab[i];
+ memset(output + first, 0, (SAMPLES_PER_FRAME - first) * sizeof(float));
+ return num_subbands;
}
- /**
+ /*
* Restore the quantized tonal components
*
- * @param gb the GetBit context
- * @param pComponent tone component
- * @param numBands amount of coded bands
+ * @param components tonal components
+ * @param num_bands number of coded bands
*/
-
- static int decodeTonalComponents (GetBitContext *gb, tonal_component *pComponent, int numBands)
+ static int decode_tonal_components(GetBitContext *gb,
+ TonalComponent *components, int num_bands)
{
- int i,j,k,cnt;
- int components, coding_mode_selector, coding_mode, coded_values_per_component;
- int sfIndx, coded_values, max_coded_values, quant_step_index, coded_components;
- int band_flags[4], mantissa[8];
- float *pCoef;
- float scalefactor;
- int component_count = 0;
+ int i, b, c, m;
+ int nb_components, coding_mode_selector, coding_mode;
+ int band_flags[4], mantissa[8];
+ int component_count = 0;
- components = get_bits(gb,5);
+ nb_components = get_bits(gb, 5);
/* no tonal components */
- if (components == 0)
+ if (nb_components == 0)
return 0;
- coding_mode_selector = get_bits(gb,2);
+ coding_mode_selector = get_bits(gb, 2);
if (coding_mode_selector == 2)
return AVERROR_INVALIDDATA;
coding_mode = coding_mode_selector & 1;
- for (i = 0; i < components; i++) {
- for (cnt = 0; cnt <= numBands; cnt++)
- band_flags[cnt] = get_bits1(gb);
+ for (i = 0; i < nb_components; i++) {
+ int coded_values_per_component, quant_step_index;
+
+ for (b = 0; b <= num_bands; b++)
+ band_flags[b] = get_bits1(gb);
- coded_values_per_component = get_bits(gb,3);
+ coded_values_per_component = get_bits(gb, 3);
- quant_step_index = get_bits(gb,3);
+ quant_step_index = get_bits(gb, 3);
if (quant_step_index <= 1)
return AVERROR_INVALIDDATA;
if (coding_mode_selector == 3)
coding_mode = get_bits1(gb);
- for (j = 0; j < (numBands + 1) * 4; j++) {
- if (band_flags[j >> 2] == 0)
+ for (b = 0; b < (num_bands + 1) * 4; b++) {
+ int coded_components;
+
+ if (band_flags[b >> 2] == 0)
continue;
- coded_components = get_bits(gb,3);
+ coded_components = get_bits(gb, 3);
+
+ for (c = 0; c < coded_components; c++) {
+ TonalComponent *cmp = &components[component_count];
+ int sf_index, coded_values, max_coded_values;
+ float scale_factor;
- for (k=0; k<coded_components; k++) {
- sfIndx = get_bits(gb,6);
+ sf_index = get_bits(gb, 6);
if (component_count >= 64)
return AVERROR_INVALIDDATA;
- pComponent[component_count].pos = j * 64 + (get_bits(gb,6));
- max_coded_values = SAMPLES_PER_FRAME - pComponent[component_count].pos;
- coded_values = coded_values_per_component + 1;
- coded_values = FFMIN(max_coded_values,coded_values);
- scalefactor = ff_atrac_sf_table[sfIndx] * iMaxQuant[quant_step_index];
+ cmp->pos = b * 64 + get_bits(gb, 6);
+
+ max_coded_values = SAMPLES_PER_FRAME - cmp->pos;
+ coded_values = coded_values_per_component + 1;
+ coded_values = FFMIN(max_coded_values, coded_values);
- readQuantSpectralCoeffs(gb, quant_step_index, coding_mode, mantissa, coded_values);
+ scale_factor = ff_atrac_sf_table[sf_index] *
+ inv_max_quant[quant_step_index];
- pComponent[component_count].numCoefs = coded_values;
+ read_quant_spectral_coeffs(gb, quant_step_index, coding_mode,
+ mantissa, coded_values);
+
+ cmp->num_coefs = coded_values;
/* inverse quant */
- pCoef = pComponent[component_count].coef;
- for (cnt = 0; cnt < coded_values; cnt++)
- pCoef[cnt] = mantissa[cnt] * scalefactor;
+ for (m = 0; m < coded_values; m++)
+ cmp->coef[m] = mantissa[m] * scale_factor;
component_count++;
}
return component_count;
}
- /**
+ /*
* Decode gain parameters for the coded bands
*
- * @param gb the GetBit context
- * @param pGb the gainblock for the current band
- * @param numBands amount of coded bands
+ * @param block the gainblock for the current band
+ * @param num_bands amount of coded bands
*/
-
- static int decodeGainControl (GetBitContext *gb, gain_block *pGb, int numBands)
+ static int decode_gain_control(GetBitContext *gb, GainBlock *block,
+ int num_bands)
{
- int i, cf, numData;
- int *pLevel, *pLoc;
-
- gain_info *pGain = pGb->gBlock;
-
- for (i=0 ; i<=numBands; i++)
- {
- numData = get_bits(gb,3);
- pGain[i].num_gain_data = numData;
- pLevel = pGain[i].levcode;
- pLoc = pGain[i].loccode;
-
- for (cf = 0; cf < numData; cf++){
- pLevel[cf]= get_bits(gb,4);
- pLoc [cf]= get_bits(gb,5);
- if(cf && pLoc[cf] <= pLoc[cf-1])
+ int i, cf, num_data;
+ int *level, *loc;
+
+ GainInfo *gain = block->g_block;
+
+ for (i = 0; i <= num_bands; i++) {
+ num_data = get_bits(gb, 3);
+ gain[i].num_gain_data = num_data;
+ level = gain[i].lev_code;
+ loc = gain[i].loc_code;
+
+ for (cf = 0; cf < gain[i].num_gain_data; cf++) {
+ level[cf] = get_bits(gb, 4);
+ loc [cf] = get_bits(gb, 5);
+ if (cf && loc[cf] <= loc[cf - 1])
return AVERROR_INVALIDDATA;
}
}
/* Clear the unused blocks. */
- for (; i<4 ; i++)
- pGain[i].num_gain_data = 0;
+ for (; i < 4 ; i++)
+ gain[i].num_gain_data = 0;
return 0;
}
- /**
+ /*
* Apply gain parameters and perform the MDCT overlapping part
*
- * @param pIn input float buffer
- * @param pPrev previous float buffer to perform overlap against
- * @param pOut output float buffer
- * @param pGain1 current band gain info
- * @param pGain2 next band gain info
+ * @param input input buffer
+ * @param prev previous buffer to perform overlap against
+ * @param output output buffer
+ * @param gain1 current band gain info
+ * @param gain2 next band gain info
*/
-
- static void gainCompensateAndOverlap (float *pIn, float *pPrev, float *pOut, gain_info *pGain1, gain_info *pGain2)
+ static void gain_compensate_and_overlap(float *input, float *prev,
+ float *output, GainInfo *gain1,
+ GainInfo *gain2)
{
- /* gain compensation function */
- float gain1, gain2, gain_inc;
- int cnt, numdata, nsample, startLoc, endLoc;
+ float g1, g2, gain_inc;
+ int i, j, num_data, start_loc, end_loc;
- if (pGain2->num_gain_data == 0)
- gain1 = 1.0;
+ if (gain2->num_gain_data == 0)
+ g1 = 1.0;
else
- gain1 = gain_tab1[pGain2->levcode[0]];
+ g1 = gain_tab1[gain2->lev_code[0]];
- if (pGain1->num_gain_data == 0) {
- for (cnt = 0; cnt < 256; cnt++)
- pOut[cnt] = pIn[cnt] * gain1 + pPrev[cnt];
+ if (gain1->num_gain_data == 0) {
+ for (i = 0; i < 256; i++)
+ output[i] = input[i] * g1 + prev[i];
} else {
- numdata = pGain1->num_gain_data;
- pGain1->loccode[numdata] = 32;
- pGain1->levcode[numdata] = 4;
-
- nsample = 0; // current sample = 0
+ num_data = gain1->num_gain_data;
+ gain1->loc_code[num_data] = 32;
+ gain1->lev_code[num_data] = 4;
- for (cnt = 0; cnt < numdata; cnt++) {
- startLoc = pGain1->loccode[cnt] * 8;
- endLoc = startLoc + 8;
+ for (i = 0, j = 0; i < num_data; i++) {
+ start_loc = gain1->loc_code[i] * 8;
+ end_loc = start_loc + 8;
- gain2 = gain_tab1[pGain1->levcode[cnt]];
- gain_inc = gain_tab2[(pGain1->levcode[cnt+1] - pGain1->levcode[cnt])+15];
+ g2 = gain_tab1[gain1->lev_code[i]];
+ gain_inc = gain_tab2[gain1->lev_code[i + 1] -
+ gain1->lev_code[i ] + 15];
/* interpolate */
- for (; nsample < startLoc; nsample++)
- pOut[nsample] = (pIn[nsample] * gain1 + pPrev[nsample]) * gain2;
+ for (; j < start_loc; j++)
+ output[j] = (input[j] * g1 + prev[j]) * g2;
/* interpolation is done over eight samples */
- for (; nsample < endLoc; nsample++) {
- pOut[nsample] = (pIn[nsample] * gain1 + pPrev[nsample]) * gain2;
- gain2 *= gain_inc;
+ for (; j < end_loc; j++) {
+ output[j] = (input[j] * g1 + prev[j]) * g2;
+ g2 *= gain_inc;
}
}
- for (; nsample < 256; nsample++)
- pOut[nsample] = (pIn[nsample] * gain1) + pPrev[nsample];
+ for (; j < 256; j++)
+ output[j] = input[j] * g1 + prev[j];
}
/* Delay for the overlapping part. */
- memcpy(pPrev, &pIn[256], 256*sizeof(float));
+ memcpy(prev, &input[256], 256 * sizeof(float));
}
- /**
+ /*
* Combine the tonal band spectrum and regular band spectrum
- * Return position of the last tonal coefficient
*
- * @param pSpectrum output spectrum buffer
- * @param numComponents amount of tonal components
- * @param pComponent tonal components for this band
+ * @param spectrum output spectrum buffer
+ * @param num_components number of tonal components
+ * @param components tonal components for this band
+ * @return position of the last tonal coefficient
*/
-
- static int addTonalComponents (float *pSpectrum, int numComponents, tonal_component *pComponent)
+ static int add_tonal_components(float *spectrum, int num_components,
+ TonalComponent *components)
{
- int cnt, i, lastPos = -1;
- float *pIn, *pOut;
+ int i, j, last_pos = -1;
+ float *input, *output;
- for (cnt = 0; cnt < numComponents; cnt++){
- lastPos = FFMAX(pComponent[cnt].pos + pComponent[cnt].numCoefs, lastPos);
- pIn = pComponent[cnt].coef;
- pOut = &(pSpectrum[pComponent[cnt].pos]);
+ for (i = 0; i < num_components; i++) {
+ last_pos = FFMAX(components[i].pos + components[i].num_coefs, last_pos);
+ input = components[i].coef;
+ output = &spectrum[components[i].pos];
- for (i=0 ; i<pComponent[cnt].numCoefs ; i++)
- pOut[i] += pIn[i];
+ for (j = 0; j < components[i].num_coefs; j++)
+ output[i] += input[i];
}
- return lastPos;
+ return last_pos;
}
+ #define INTERPOLATE(old, new, nsample) \
+ ((old) + (nsample) * 0.125 * ((new) - (old)))
- #define INTERPOLATE(old,new,nsample) ((old) + (nsample)*0.125*((new)-(old)))
-
- static void reverseMatrixing(float *su1, float *su2, int *pPrevCode, int *pCurrCode)
+ static void reverse_matrixing(float *su1, float *su2, int *prev_code,
+ int *curr_code)
{
- int i, band, nsample, s1, s2;
- float c1, c2;
- float mc1_l, mc1_r, mc2_l, mc2_r;
+ int i, nsample, band;
+ float mc1_l, mc1_r, mc2_l, mc2_r;
- for (i=0,band = 0; band < 4*256; band+=256,i++) {
- s1 = pPrevCode[i];
- s2 = pCurrCode[i];
- nsample = 0;
+ for (i = 0, band = 0; band < 4 * 256; band += 256, i++) {
+ int s1 = prev_code[i];
+ int s2 = curr_code[i];
+ nsample = band;
if (s1 != s2) {
/* Selector value changed, interpolation needed. */
- mc1_l = matrixCoeffs[s1*2];
- mc1_r = matrixCoeffs[s1*2+1];
- mc2_l = matrixCoeffs[s2*2];
- mc2_r = matrixCoeffs[s2*2+1];
+ mc1_l = matrix_coeffs[s1 * 2 ];
+ mc1_r = matrix_coeffs[s1 * 2 + 1];
+ mc2_l = matrix_coeffs[s2 * 2 ];
+ mc2_r = matrix_coeffs[s2 * 2 + 1];
/* Interpolation is done over the first eight samples. */
- for(; nsample < 8; nsample++) {
- c1 = su1[band+nsample];
- c2 = su2[band+nsample];
- c2 = c1 * INTERPOLATE(mc1_l,mc2_l,nsample) + c2 * INTERPOLATE(mc1_r,mc2_r,nsample);
- su1[band+nsample] = c2;
- su2[band+nsample] = c1 * 2.0 - c2;
+ for (; nsample < band + 8; nsample++) {
+ float c1 = su1[nsample];
+ float c2 = su2[nsample];
+ c2 = c1 * INTERPOLATE(mc1_l, mc2_l, nsample - band) +
+ c2 * INTERPOLATE(mc1_r, mc2_r, nsample - band);
+ su1[nsample] = c2;
+ su2[nsample] = c1 * 2.0 - c2;
}
}
/* Apply the matrix without interpolation. */
switch (s2) {
- case 0: /* M/S decoding */
- for (; nsample < 256; nsample++) {
- c1 = su1[band+nsample];
- c2 = su2[band+nsample];
- su1[band+nsample] = c2 * 2.0;
- su2[band+nsample] = (c1 - c2) * 2.0;
- }
- break;
-
- case 1:
- for (; nsample < 256; nsample++) {
- c1 = su1[band+nsample];
- c2 = su2[band+nsample];
- su1[band+nsample] = (c1 + c2) * 2.0;
- su2[band+nsample] = c2 * -2.0;
- }
- break;
- case 2:
- case 3:
- for (; nsample < 256; nsample++) {
- c1 = su1[band+nsample];
- c2 = su2[band+nsample];
- su1[band+nsample] = c1 + c2;
- su2[band+nsample] = c1 - c2;
- }
- break;
- default:
- av_assert1(0);
+ case 0: /* M/S decoding */
+ for (; nsample < band + 256; nsample++) {
+ float c1 = su1[nsample];
+ float c2 = su2[nsample];
+ su1[nsample] = c2 * 2.0;
+ su2[nsample] = (c1 - c2) * 2.0;
+ }
+ break;
+ case 1:
+ for (; nsample < band + 256; nsample++) {
+ float c1 = su1[nsample];
+ float c2 = su2[nsample];
+ su1[nsample] = (c1 + c2) * 2.0;
+ su2[nsample] = c2 * -2.0;
+ }
+ break;
+ case 2:
+ case 3:
+ for (; nsample < band + 256; nsample++) {
+ float c1 = su1[nsample];
+ float c2 = su2[nsample];
+ su1[nsample] = c1 + c2;
+ su2[nsample] = c1 - c2;
+ }
+ break;
+ default:
- assert(0);
++ av_assert1(0);
}
}
}
- static void getChannelWeights (int indx, int flag, float ch[2]){
-
- if (indx == 7) {
+ static void get_channel_weights(int index, int flag, float ch[2])
+ {
+ if (index == 7) {
ch[0] = 1.0;
ch[1] = 1.0;
} else {
- ch[0] = (float)(indx & 7) / 7.0;
- ch[1] = sqrt(2 - ch[0]*ch[0]);
- if(flag)
+ ch[0] = (index & 7) / 7.0;
+ ch[1] = sqrt(2 - ch[0] * ch[0]);
+ if (flag)
FFSWAP(float, ch[0], ch[1]);
}
}
- static void channelWeighting (float *su1, float *su2, int *p3)
+ static void channel_weighting(float *su1, float *su2, int *p3)
{
- int band, nsample;
+ int band, nsample;
/* w[x][y] y=0 is left y=1 is right */
float w[2][2];
- if (p3[1] != 7 || p3[3] != 7){
- getChannelWeights(p3[1], p3[0], w[0]);
- getChannelWeights(p3[3], p3[2], w[1]);
+ if (p3[1] != 7 || p3[3] != 7) {
+ get_channel_weights(p3[1], p3[0], w[0]);
+ get_channel_weights(p3[3], p3[2], w[1]);
- for(band = 1; band < 4; band++) {
- /* scale the channels by the weights */
- for(nsample = 0; nsample < 8; nsample++) {
- su1[band*256+nsample] *= INTERPOLATE(w[0][0], w[0][1], nsample);
- su2[band*256+nsample] *= INTERPOLATE(w[1][0], w[1][1], nsample);
+ for (band = 256; band < 4 * 256; band += 256) {
+ for (nsample = band; nsample < band + 8; nsample++) {
+ su1[nsample] *= INTERPOLATE(w[0][0], w[0][1], nsample - band);
+ su2[nsample] *= INTERPOLATE(w[1][0], w[1][1], nsample - band);
}
-
- for(; nsample < 256; nsample++) {
- su1[band*256+nsample] *= w[1][0];
- su2[band*256+nsample] *= w[1][1];
+ for(; nsample < band + 256; nsample++) {
+ su1[nsample] *= w[1][0];
+ su2[nsample] *= w[1][1];
}
}
}
}
-
- /**
+ /*
* Decode a Sound Unit
*
- * @param gb the GetBit context
- * @param pSnd the channel unit to be used
- * @param pOut the decoded samples before IQMF in float representation
- * @param channelNum channel number
- * @param codingMode the coding mode (JOINT_STEREO or regular stereo/mono)
+ * @param snd the channel unit to be used
+ * @param output the decoded samples before IQMF in float representation
+ * @param channel_num channel number
+ * @param coding_mode the coding mode (JOINT_STEREO or regular stereo/mono)
*/
-
-
- static int decodeChannelSoundUnit (ATRAC3Context *q, GetBitContext *gb, channel_unit *pSnd, float *pOut, int channelNum, int codingMode)
+ static int decode_channel_sound_unit(ATRAC3Context *q, GetBitContext *gb,
+ ChannelUnit *snd, float *output,
+ int channel_num, int coding_mode)
{
- int band, result=0, numSubbands, lastTonal, numBands;
+ int band, ret, num_subbands, last_tonal, num_bands;
+ GainBlock *gain1 = &snd->gain_block[ snd->gc_blk_switch];
+ GainBlock *gain2 = &snd->gain_block[1 - snd->gc_blk_switch];
- if (codingMode == JOINT_STEREO && channelNum == 1) {
- if (get_bits(gb,2) != 3) {
+ if (coding_mode == JOINT_STEREO && channel_num == 1) {
+ if (get_bits(gb, 2) != 3) {
av_log(NULL,AV_LOG_ERROR,"JS mono Sound Unit id != 3.\n");
return AVERROR_INVALIDDATA;
}
} else {
- if (get_bits(gb,6) != 0x28) {
+ if (get_bits(gb, 6) != 0x28) {
av_log(NULL,AV_LOG_ERROR,"Sound Unit id != 0x28.\n");
return AVERROR_INVALIDDATA;
}
}
/* number of coded QMF bands */
- pSnd->bandsCoded = get_bits(gb,2);
+ snd->bands_coded = get_bits(gb, 2);
- result = decodeGainControl (gb, &(pSnd->gainBlock[pSnd->gcBlkSwitch]), pSnd->bandsCoded);
- if (result) return result;
+ ret = decode_gain_control(gb, gain2, snd->bands_coded);
+ if (ret)
+ return ret;
- pSnd->numComponents = decodeTonalComponents (gb, pSnd->components, pSnd->bandsCoded);
- if (pSnd->numComponents == -1) return -1;
+ snd->num_components = decode_tonal_components(gb, snd->components,
+ snd->bands_coded);
+ if (snd->num_components == -1)
+ return -1;
- numSubbands = decodeSpectrum (gb, pSnd->spectrum);
+ num_subbands = decode_spectrum(gb, snd->spectrum);
/* Merge the decoded spectrum and tonal components. */
- lastTonal = addTonalComponents (pSnd->spectrum, pSnd->numComponents, pSnd->components);
+ last_tonal = add_tonal_components(snd->spectrum, snd->num_components,
+ snd->components);
- /* calculate number of used MLT/QMF bands according to the amount of coded spectral lines */
- numBands = (subbandTab[numSubbands] - 1) >> 8;
- if (lastTonal >= 0)
- numBands = FFMAX((lastTonal + 256) >> 8, numBands);
+ /* calculate number of used MLT/QMF bands according to the amount of coded
+ spectral lines */
+ num_bands = (subband_tab[num_subbands] - 1) >> 8;
+ if (last_tonal >= 0)
+ num_bands = FFMAX((last_tonal + 256) >> 8, num_bands);
/* Reconstruct time domain samples. */
- for (band=0; band<4; band++) {
+ for (band = 0; band < 4; band++) {
/* Perform the IMDCT step without overlapping. */
- if (band <= numBands) {
- IMLT(q, &(pSnd->spectrum[band*256]), pSnd->IMDCT_buf, band&1);
- } else
- memset(pSnd->IMDCT_buf, 0, 512 * sizeof(float));
+ if (band <= num_bands)
+ imlt(q, &snd->spectrum[band * 256], snd->imdct_buf, band & 1);
+ else
+ memset(snd->imdct_buf, 0, 512 * sizeof(float));
/* gain compensation and overlapping */
- gainCompensateAndOverlap(pSnd->IMDCT_buf, &pSnd->prevFrame[band * 256],
- &pOut[band * 256],
- &pSnd->gainBlock[1 - pSnd->gcBlkSwitch].gBlock[band],
- &pSnd->gainBlock[ pSnd->gcBlkSwitch].gBlock[band]);
+ gain_compensate_and_overlap(snd->imdct_buf,
+ &snd->prev_frame[band * 256],
+ &output[band * 256],
+ &gain1->g_block[band],
+ &gain2->g_block[band]);
}
/* Swap the gain control buffers for the next frame. */
- pSnd->gcBlkSwitch ^= 1;
+ snd->gc_blk_switch ^= 1;
return 0;
}
- /**
- * Frame handling
- *
- * @param q Atrac3 private context
- * @param databuf the input data
- */
-
- static int decodeFrame(ATRAC3Context *q, const uint8_t* databuf,
- float **out_samples)
+ static int decode_frame(AVCodecContext *avctx, const uint8_t *databuf,
+ float **out_samples)
{
- int result, i;
- float *p1, *p2, *p3, *p4;
+ ATRAC3Context *q = avctx->priv_data;
+ int ret, i;
uint8_t *ptr1;
- if (q->codingMode == JOINT_STEREO) {
-
+ if (q->coding_mode == JOINT_STEREO) {
/* channel coupling mode */
/* decode Sound Unit 1 */
init_get_bits(&q->gb,databuf,q->bits_per_frame);
- result = decodeChannelSoundUnit(q,&q->gb, q->pUnits, out_samples[0], 0, JOINT_STEREO);
- if (result != 0)
- return result;
+ ret = decode_channel_sound_unit(q, &q->gb, q->units, out_samples[0], 0,
+ JOINT_STEREO);
+ if (ret != 0)
+ return ret;
/* Framedata of the su2 in the joint-stereo mode is encoded in
* reverse byte order so we need to swap it first. */
if (databuf == q->decoded_bytes_buffer) {
- uint8_t *ptr2 = q->decoded_bytes_buffer+q->bytes_per_frame-1;
- ptr1 = q->decoded_bytes_buffer;
- for (i = 0; i < (q->bytes_per_frame/2); i++, ptr1++, ptr2--) {
- FFSWAP(uint8_t,*ptr1,*ptr2);
- }
+ uint8_t *ptr2 = q->decoded_bytes_buffer + q->bytes_per_frame - 1;
+ ptr1 = q->decoded_bytes_buffer;
+ for (i = 0; i < q->bytes_per_frame / 2; i++, ptr1++, ptr2--)
+ FFSWAP(uint8_t, *ptr1, *ptr2);
} else {
- const uint8_t *ptr2 = databuf+q->bytes_per_frame-1;
+ const uint8_t *ptr2 = databuf + q->bytes_per_frame - 1;
for (i = 0; i < q->bytes_per_frame; i++)
q->decoded_bytes_buffer[i] = *ptr2--;
}
/* set the bitstream reader at the start of the second Sound Unit*/
- init_get_bits(&q->gb,ptr1,q->bits_per_frame);
+ init_get_bits(&q->gb, ptr1, q->bits_per_frame);
/* Fill the Weighting coeffs delay buffer */
- memmove(q->weighting_delay,&(q->weighting_delay[2]),4*sizeof(int));
+ memmove(q->weighting_delay, &q->weighting_delay[2], 4 * sizeof(int));
q->weighting_delay[4] = get_bits1(&q->gb);
- q->weighting_delay[5] = get_bits(&q->gb,3);
+ q->weighting_delay[5] = get_bits(&q->gb, 3);
for (i = 0; i < 4; i++) {
q->matrix_coeff_index_prev[i] = q->matrix_coeff_index_now[i];
- q->matrix_coeff_index_now[i] = q->matrix_coeff_index_next[i];
- q->matrix_coeff_index_next[i] = get_bits(&q->gb,2);
+ q->matrix_coeff_index_now[i] = q->matrix_coeff_index_next[i];
+ q->matrix_coeff_index_next[i] = get_bits(&q->gb, 2);
}
/* Decode Sound Unit 2. */
- result = decodeChannelSoundUnit(q,&q->gb, &q->pUnits[1], out_samples[1], 1, JOINT_STEREO);
- if (result != 0)
- return result;
+ ret = decode_channel_sound_unit(q, &q->gb, &q->units[1],
+ out_samples[1], 1, JOINT_STEREO);
+ if (ret != 0)
+ return ret;
/* Reconstruct the channel coefficients. */
- reverseMatrixing(out_samples[0], out_samples[1], q->matrix_coeff_index_prev, q->matrix_coeff_index_now);
-
- channelWeighting(out_samples[0], out_samples[1], q->weighting_delay);
+ reverse_matrixing(out_samples[0], out_samples[1],
+ q->matrix_coeff_index_prev,
+ q->matrix_coeff_index_now);
+ channel_weighting(out_samples[0], out_samples[1], q->weighting_delay);
} else {
/* normal stereo mode or mono */
/* Decode the channel sound units. */
- for (i=0 ; i<q->channels ; i++) {
-
+ for (i = 0; i < avctx->channels; i++) {
/* Set the bitstream reader at the start of a channel sound unit. */
init_get_bits(&q->gb,
- databuf + i * q->bytes_per_frame / q->channels,
- q->bits_per_frame / q->channels);
+ databuf + i * q->bytes_per_frame / avctx->channels,
+ q->bits_per_frame / avctx->channels);
- result = decodeChannelSoundUnit(q,&q->gb, &q->pUnits[i], out_samples[i], i, q->codingMode);
- if (result != 0)
- return result;
+ ret = decode_channel_sound_unit(q, &q->gb, &q->units[i],
+ out_samples[i], i, q->coding_mode);
+ if (ret != 0)
+ return ret;
}
}
/* Apply the iQMF synthesis filter. */
- for (i=0 ; i<q->channels ; i++) {
- p1 = out_samples[i];
- p2= p1+256;
- p3= p2+256;
- p4= p3+256;
- ff_atrac_iqmf (p1, p2, 256, p1, q->pUnits[i].delayBuf1, q->tempBuf);
- ff_atrac_iqmf (p4, p3, 256, p3, q->pUnits[i].delayBuf2, q->tempBuf);
- ff_atrac_iqmf (p1, p3, 512, p1, q->pUnits[i].delayBuf3, q->tempBuf);
+ for (i = 0; i < avctx->channels; i++) {
+ float *p1 = out_samples[i];
+ float *p2 = p1 + 256;
+ float *p3 = p2 + 256;
+ float *p4 = p3 + 256;
+ ff_atrac_iqmf(p1, p2, 256, p1, q->units[i].delay_buf1, q->temp_buf);
+ ff_atrac_iqmf(p4, p3, 256, p3, q->units[i].delay_buf2, q->temp_buf);
+ ff_atrac_iqmf(p1, p3, 512, p1, q->units[i].delay_buf3, q->temp_buf);
}
return 0;
}
-
- /**
- * Atrac frame decoding
- *
- * @param avctx pointer to the AVCodecContext
- */
-
static int atrac3_decode_frame(AVCodecContext *avctx, void *data,
int *got_frame_ptr, AVPacket *avpkt)
{
const uint8_t *buf = avpkt->data;
int buf_size = avpkt->size;
ATRAC3Context *q = avctx->priv_data;
- int result;
- const uint8_t* databuf;
+ int ret;
+ const uint8_t *databuf;
if (buf_size < avctx->block_align) {
av_log(avctx, AV_LOG_ERROR,
/* get output buffer */
q->frame.nb_samples = SAMPLES_PER_FRAME;
- if ((result = avctx->get_buffer(avctx, &q->frame)) < 0) {
+ if ((ret = avctx->get_buffer(avctx, &q->frame)) < 0) {
av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
- return result;
+ return ret;
}
/* Check if we need to descramble and what buffer to pass on. */
databuf = buf;
}
- result = decodeFrame(q, databuf, (float **)q->frame.extended_data);
-
- if (result != 0) {
- av_log(NULL,AV_LOG_ERROR,"Frame decoding error!\n");
- return result;
+ ret = decode_frame(avctx, databuf, (float **)q->frame.extended_data);
+ if (ret) {
+ av_log(NULL, AV_LOG_ERROR, "Frame decoding error!\n");
+ return ret;
}
*got_frame_ptr = 1;
return avctx->block_align;
}
-
- /**
- * Atrac3 initialization
- *
- * @param avctx pointer to the AVCodecContext
- */
-
static av_cold int atrac3_decode_init(AVCodecContext *avctx)
{
int i, ret;
static int vlcs_initialized = 0;
/* Take data from the AVCodecContext (RM container). */
- q->sample_rate = avctx->sample_rate;
- q->channels = avctx->channels;
- q->bit_rate = avctx->bit_rate;
- q->bits_per_frame = avctx->block_align * 8;
+ q->sample_rate = avctx->sample_rate;
+ q->bit_rate = avctx->bit_rate;
+ q->bits_per_frame = avctx->block_align * 8;
q->bytes_per_frame = avctx->block_align;
+ if (avctx->channels <= 0 || avctx->channels > 2) {
+ av_log(avctx, AV_LOG_ERROR, "Channel configuration error!\n");
+ return AVERROR(EINVAL);
+ }
+
/* Take care of the codec-specific extradata. */
if (avctx->extradata_size == 14) {
/* Parse the extradata, WAV format */
- av_log(avctx,AV_LOG_DEBUG,"[0-1] %d\n",bytestream_get_le16(&edata_ptr)); //Unknown value always 1
+ av_log(avctx, AV_LOG_DEBUG, "[0-1] %d\n",
+ bytestream_get_le16(&edata_ptr)); // Unknown value always 1
q->samples_per_channel = bytestream_get_le32(&edata_ptr);
- q->codingMode = bytestream_get_le16(&edata_ptr);
- av_log(avctx,AV_LOG_DEBUG,"[8-9] %d\n",bytestream_get_le16(&edata_ptr)); //Dupe of coding mode
- q->frame_factor = bytestream_get_le16(&edata_ptr); //Unknown always 1
- av_log(avctx,AV_LOG_DEBUG,"[12-13] %d\n",bytestream_get_le16(&edata_ptr)); //Unknown always 0
+ q->coding_mode = bytestream_get_le16(&edata_ptr);
+ av_log(avctx, AV_LOG_DEBUG,"[8-9] %d\n",
+ bytestream_get_le16(&edata_ptr)); //Dupe of coding mode
+ q->frame_factor = bytestream_get_le16(&edata_ptr); // Unknown always 1
+ av_log(avctx, AV_LOG_DEBUG,"[12-13] %d\n",
+ bytestream_get_le16(&edata_ptr)); // Unknown always 0
/* setup */
- q->samples_per_frame = SAMPLES_PER_FRAME * q->channels;
- q->atrac3version = 4;
- q->delay = 0x88E;
- if (q->codingMode)
- q->codingMode = JOINT_STEREO;
- else
- q->codingMode = STEREO;
-
- q->scrambled_stream = 0;
-
- if ((q->bytes_per_frame == 96*q->channels*q->frame_factor) || (q->bytes_per_frame == 152*q->channels*q->frame_factor) || (q->bytes_per_frame == 192*q->channels*q->frame_factor)) {
- } else {
- av_log(avctx,AV_LOG_ERROR,"Unknown frame/channel/frame_factor configuration %d/%d/%d\n", q->bytes_per_frame, q->channels, q->frame_factor);
+ q->samples_per_frame = SAMPLES_PER_FRAME * avctx->channels;
+ q->version = 4;
+ q->delay = 0x88E;
+ q->coding_mode = q->coding_mode ? JOINT_STEREO : STEREO;
+ q->scrambled_stream = 0;
+
+ if (q->bytes_per_frame != 96 * avctx->channels * q->frame_factor &&
+ q->bytes_per_frame != 152 * avctx->channels * q->frame_factor &&
+ q->bytes_per_frame != 192 * avctx->channels * q->frame_factor) {
+ av_log(avctx, AV_LOG_ERROR, "Unknown frame/channel/frame_factor "
+ "configuration %d/%d/%d\n", q->bytes_per_frame,
+ avctx->channels, q->frame_factor);
return AVERROR_INVALIDDATA;
}
-
} else if (avctx->extradata_size == 10) {
/* Parse the extradata, RM format. */
- q->atrac3version = bytestream_get_be32(&edata_ptr);
- q->samples_per_frame = bytestream_get_be16(&edata_ptr);
- q->delay = bytestream_get_be16(&edata_ptr);
- q->codingMode = bytestream_get_be16(&edata_ptr);
-
- q->samples_per_channel = q->samples_per_frame / q->channels;
- q->scrambled_stream = 1;
+ q->version = bytestream_get_be32(&edata_ptr);
+ q->samples_per_frame = bytestream_get_be16(&edata_ptr);
+ q->delay = bytestream_get_be16(&edata_ptr);
+ q->coding_mode = bytestream_get_be16(&edata_ptr);
+ q->samples_per_channel = q->samples_per_frame / avctx->channels;
+ q->scrambled_stream = 1;
} else {
- av_log(NULL,AV_LOG_ERROR,"Unknown extradata size %d.\n",avctx->extradata_size);
+ av_log(NULL, AV_LOG_ERROR, "Unknown extradata size %d.\n",
+ avctx->extradata_size);
}
- /* Check the extradata. */
- if (q->atrac3version != 4) {
- av_log(avctx,AV_LOG_ERROR,"Version %d != 4.\n",q->atrac3version);
+ /* Check the extradata */
+
+ if (q->version != 4) {
+ av_log(avctx, AV_LOG_ERROR, "Version %d != 4.\n", q->version);
return AVERROR_INVALIDDATA;
}
- if (q->samples_per_frame != SAMPLES_PER_FRAME && q->samples_per_frame != SAMPLES_PER_FRAME*2) {
- av_log(avctx,AV_LOG_ERROR,"Unknown amount of samples per frame %d.\n",q->samples_per_frame);
+ if (q->samples_per_frame != SAMPLES_PER_FRAME &&
+ q->samples_per_frame != SAMPLES_PER_FRAME * 2) {
+ av_log(avctx, AV_LOG_ERROR, "Unknown amount of samples per frame %d.\n",
+ q->samples_per_frame);
return AVERROR_INVALIDDATA;
}
if (q->delay != 0x88E) {
- av_log(avctx,AV_LOG_ERROR,"Unknown amount of delay %x != 0x88E.\n",q->delay);
+ av_log(avctx, AV_LOG_ERROR, "Unknown amount of delay %x != 0x88E.\n",
+ q->delay);
return AVERROR_INVALIDDATA;
}
- if (q->codingMode == STEREO) {
- av_log(avctx,AV_LOG_DEBUG,"Normal stereo detected.\n");
- } else if (q->codingMode == JOINT_STEREO) {
- av_log(avctx,AV_LOG_DEBUG,"Joint stereo detected.\n");
- } else {
- av_log(avctx,AV_LOG_ERROR,"Unknown channel coding mode %x!\n",q->codingMode);
+ if (q->coding_mode == STEREO)
+ av_log(avctx, AV_LOG_DEBUG, "Normal stereo detected.\n");
+ else if (q->coding_mode == JOINT_STEREO)
+ av_log(avctx, AV_LOG_DEBUG, "Joint stereo detected.\n");
+ else {
+ av_log(avctx, AV_LOG_ERROR, "Unknown channel coding mode %x!\n",
+ q->coding_mode);
return AVERROR_INVALIDDATA;
}
- if (avctx->channels <= 0 || avctx->channels > 2 /*|| ((avctx->channels * 1024) != q->samples_per_frame)*/) {
- av_log(avctx,AV_LOG_ERROR,"Channel configuration error!\n");
- return AVERROR(EINVAL);
- }
-
-
- if(avctx->block_align >= UINT_MAX/2)
+ if (avctx->block_align >= UINT_MAX / 2)
return AVERROR(EINVAL);
- /* Pad the data buffer with FF_INPUT_BUFFER_PADDING_SIZE,
- * this is for the bitstream reader. */
- if ((q->decoded_bytes_buffer = av_mallocz((avctx->block_align+(4-avctx->block_align%4) + FF_INPUT_BUFFER_PADDING_SIZE))) == NULL)
+ q->decoded_bytes_buffer = av_mallocz(avctx->block_align +
+ (4 - avctx->block_align % 4) +
+ FF_INPUT_BUFFER_PADDING_SIZE);
+ if (q->decoded_bytes_buffer == NULL)
return AVERROR(ENOMEM);
/* Initialize the VLC tables. */
if (!vlcs_initialized) {
- for (i=0 ; i<7 ; i++) {
+ for (i = 0; i < 7; i++) {
spectral_coeff_tab[i].table = &atrac3_vlc_table[atrac3_vlc_offs[i]];
- spectral_coeff_tab[i].table_allocated = atrac3_vlc_offs[i + 1] - atrac3_vlc_offs[i];
- init_vlc (&spectral_coeff_tab[i], 9, huff_tab_sizes[i],
- huff_bits[i], 1, 1,
- huff_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
+ spectral_coeff_tab[i].table_allocated = atrac3_vlc_offs[i + 1] -
+ atrac3_vlc_offs[i ];
+ init_vlc(&spectral_coeff_tab[i], 9, huff_tab_sizes[i],
+ huff_bits[i], 1, 1,
+ huff_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
}
vlcs_initialized = 1;
}
ff_atrac_generate_tables();
- /* Generate gain tables. */
- for (i=0 ; i<16 ; i++)
+ /* Generate gain tables */
+ for (i = 0; i < 16; i++)
- gain_tab1[i] = powf(2.0, (4 - i));
+ gain_tab1[i] = exp2f (4 - i);
- for (i=-15 ; i<16 ; i++)
- gain_tab2[i+15] = exp2f (i * -0.125);
+ for (i = -15; i < 16; i++)
- gain_tab2[i + 15] = powf(2.0, i * -0.125);
++ gain_tab2[i + 15] = exp2f (i * -0.125);
/* init the joint-stereo decoding data */
q->weighting_delay[0] = 0;
q->weighting_delay[4] = 0;
q->weighting_delay[5] = 7;
- for (i=0; i<4; i++) {
+ for (i = 0; i < 4; i++) {
q->matrix_coeff_index_prev[i] = 3;
- q->matrix_coeff_index_now[i] = 3;
+ q->matrix_coeff_index_now[i] = 3;
q->matrix_coeff_index_next[i] = 3;
}
avpriv_float_dsp_init(&q->fdsp, avctx->flags & CODEC_FLAG_BITEXACT);
ff_fmt_convert_init(&q->fmt_conv, avctx);
- q->pUnits = av_mallocz(sizeof(channel_unit)*q->channels);
- if (!q->pUnits) {
+ q->units = av_mallocz(sizeof(ChannelUnit) * avctx->channels);
+ if (!q->units) {
atrac3_decode_close(avctx);
return AVERROR(ENOMEM);
}
return 0;
}
-
- AVCodec ff_atrac3_decoder =
- {
- .name = "atrac3",
- .type = AVMEDIA_TYPE_AUDIO,
- .id = AV_CODEC_ID_ATRAC3,
- .priv_data_size = sizeof(ATRAC3Context),
- .init = atrac3_decode_init,
- .close = atrac3_decode_close,
- .decode = atrac3_decode_frame,
- .capabilities = CODEC_CAP_SUBFRAMES | CODEC_CAP_DR1,
- .long_name = NULL_IF_CONFIG_SMALL("Atrac 3 (Adaptive TRansform Acoustic Coding 3)"),
- .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
- AV_SAMPLE_FMT_NONE },
+ AVCodec ff_atrac3_decoder = {
+ .name = "atrac3",
+ .type = AVMEDIA_TYPE_AUDIO,
+ .id = AV_CODEC_ID_ATRAC3,
+ .priv_data_size = sizeof(ATRAC3Context),
+ .init = atrac3_decode_init,
+ .close = atrac3_decode_close,
+ .decode = atrac3_decode_frame,
+ .capabilities = CODEC_CAP_SUBFRAMES | CODEC_CAP_DR1,
+ .long_name = NULL_IF_CONFIG_SMALL("Atrac 3 (Adaptive TRansform Acoustic Coding 3)"),
+ .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
+ AV_SAMPLE_FMT_NONE },
};
* Copyright (c) 2006-2007 Maxim Poliakovski
* Copyright (c) 2006-2007 Benjamin Larsson
*
- * This file is part of Libav.
+ * This file is part of FFmpeg.
*
- * Libav is free software; you can redistribute it and/or
+ * 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.
*
- * Libav is distributed in the hope that it will be useful,
+ * 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 Libav; if not, write to the Free Software
+ * License along with FFmpeg; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
/* VLC tables */
static const uint8_t huffcode1[9] = {
- 0x0,0x4,0x5,0xC,0xD,0x1C,0x1D,0x1E,0x1F,
+ 0x0, 0x4, 0x5, 0xC, 0xD, 0x1C, 0x1D, 0x1E, 0x1F
};
- static const uint8_t huffbits1[9] = {
- 1,3,3,4,4,5,5,5,5,
- };
+ static const uint8_t huffbits1[9] = { 1, 3, 3, 4, 4, 5, 5, 5, 5 };
- static const uint8_t huffcode2[5] = {
- 0x0,0x4,0x5,0x6,0x7,
- };
+ static const uint8_t huffcode2[5] = { 0x0, 0x4, 0x5, 0x6, 0x7 };
- static const uint8_t huffbits2[5] = {
- 1,3,3,3,3,
- };
+ static const uint8_t huffbits2[5] = { 1, 3, 3, 3, 3 };
- static const uint8_t huffcode3[7] = {
- 0x0,0x4,0x5,0xC,0xD,0xE,0xF,
- };
+ static const uint8_t huffcode3[7] = { 0x0, 0x4, 0x5, 0xC, 0xD, 0xE, 0xF };
- static const uint8_t huffbits3[7] = {
- 1,3,3,4,4,4,4,
- };
+ static const uint8_t huffbits3[7] = { 1, 3, 3, 4, 4, 4, 4 };
static const uint8_t huffcode4[9] = {
- 0x0,0x4,0x5,0xC,0xD,0x1C,0x1D,0x1E,0x1F,
+ 0x0, 0x4, 0x5, 0xC, 0xD, 0x1C, 0x1D, 0x1E, 0x1F
};
- static const uint8_t huffbits4[9] = {
- 1,3,3,4,4,5,5,5,5,
- };
+ static const uint8_t huffbits4[9] = { 1, 3, 3, 4, 4, 5, 5, 5, 5 };
static const uint8_t huffcode5[15] = {
- 0x0,0x2,0x3,0x8,0x9,0xA,0xB,0x1C,0x1D,0x3C,0x3D,0x3E,0x3F,0xC,0xD,
+ 0x00, 0x02, 0x03, 0x08, 0x09, 0x0A, 0x0B, 0x1C,
+ 0x1D, 0x3C, 0x3D, 0x3E, 0x3F, 0x0C, 0x0D
};
static const uint8_t huffbits5[15] = {
- 2,3,3,4,4,4,4,5,5,6,6,6,6,4,4
+ 2, 3, 3, 4, 4, 4, 4, 5, 5, 6, 6, 6, 6, 4, 4
};
static const uint8_t huffcode6[31] = {
- 0x0,0x2,0x3,0x4,0x5,0x6,0x7,0x14,0x15,0x16,0x17,0x18,0x19,0x34,0x35,
- 0x36,0x37,0x38,0x39,0x3A,0x3B,0x78,0x79,0x7A,0x7B,0x7C,0x7D,0x7E,0x7F,0x8,0x9,
+ 0x00, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x14,
+ 0x15, 0x16, 0x17, 0x18, 0x19, 0x34, 0x35, 0x36,
+ 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x78, 0x79, 0x7A,
+ 0x7B, 0x7C, 0x7D, 0x7E, 0x7F, 0x08, 0x09
};
static const uint8_t huffbits6[31] = {
- 3,4,4,4,4,4,4,5,5,5,5,5,5,6,6,6,6,6,6,6,6,7,7,7,7,7,7,7,7,4,4
+ 3, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6,
+ 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 4, 4
};
static const uint8_t huffcode7[63] = {
- 0x0,0x8,0x9,0xA,0xB,0xC,0xD,0xE,0xF,0x10,0x11,0x24,0x25,0x26,0x27,0x28,
- 0x29,0x2A,0x2B,0x2C,0x2D,0x2E,0x2F,0x30,0x31,0x32,0x33,0x68,0x69,0x6A,0x6B,0x6C,
- 0x6D,0x6E,0x6F,0x70,0x71,0x72,0x73,0x74,0x75,0xEC,0xED,0xEE,0xEF,0xF0,0xF1,0xF2,
- 0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF,0x2,0x3,
+ 0x00, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E,
+ 0x0F, 0x10, 0x11, 0x24, 0x25, 0x26, 0x27, 0x28,
+ 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30,
+ 0x31, 0x32, 0x33, 0x68, 0x69, 0x6A, 0x6B, 0x6C,
+ 0x6D, 0x6E, 0x6F, 0x70, 0x71, 0x72, 0x73, 0x74,
+ 0x75, 0xEC, 0xED, 0xEE, 0xEF, 0xF0, 0xF1, 0xF2,
+ 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA,
+ 0xFB, 0xFC, 0xFD, 0xFE, 0xFF, 0x02, 0x03
};
static const uint8_t huffbits7[63] = {
- 3,5,5,5,5,5,5,5,5,5,5,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,7,7,7,7,7,
- 7,7,7,7,7,7,7,7,7,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,4,4
+ 3, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6,
+ 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7,
+ 7, 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8,
+ 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 4, 4
};
static const uint8_t huff_tab_sizes[7] = {
- 9, 5, 7, 9, 15, 31, 63,
+ 9, 5, 7, 9, 15, 31, 63,
};
static const uint8_t* const huff_codes[7] = {
- huffcode1,huffcode2,huffcode3,huffcode4,huffcode5,huffcode6,huffcode7,
+ huffcode1, huffcode2, huffcode3, huffcode4, huffcode5, huffcode6, huffcode7
};
static const uint8_t* const huff_bits[7] = {
- huffbits1,huffbits2,huffbits3,huffbits4,huffbits5,huffbits6,huffbits7,
+ huffbits1, huffbits2, huffbits3, huffbits4, huffbits5, huffbits6, huffbits7,
};
- static const uint16_t atrac3_vlc_offs[] = {
- 0,512,1024,1536,2048,2560,3072,3584,4096
+ static const uint16_t atrac3_vlc_offs[9] = {
+ 0, 512, 1024, 1536, 2048, 2560, 3072, 3584, 4096
};
/* selector tables */
- static const uint8_t CLCLengthTab[8] = {0, 4, 3, 3, 4, 4, 5, 6};
- static const int8_t seTab_0[4] = {0, 1, -2, -1};
- static const int8_t decTable1[18] = {0,0, 0,1, 0,-1, 1,0, -1,0, 1,1, 1,-1, -1,1, -1,-1};
+ static const uint8_t clc_length_tab[8] = { 0, 4, 3, 3, 4, 4, 5, 6 };
+
+ static const int8_t mantissa_clc_tab[4] = { 0, 1, -2, -1 };
+
+ static const int8_t mantissa_vlc_tab[18] = {
+ 0, 0, 0, 1, 0, -1, 1, 0, -1, 0, 1, 1, 1, -1, -1, 1, -1, -1
+ };
/* tables for the scalefactor decoding */
- static const float iMaxQuant[8] = {
- 0.0, 1.0/1.5, 1.0/2.5, 1.0/3.5, 1.0/4.5, 1.0/7.5, 1.0/15.5, 1.0/31.5
+ static const float inv_max_quant[8] = {
+ 0.0, 1.0 / 1.5, 1.0 / 2.5, 1.0 / 3.5,
+ 1.0 / 4.5, 1.0 / 7.5, 1.0 / 15.5, 1.0 / 31.5
};
- static const uint16_t subbandTab[33] = {
- 0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, 176, 192, 224,
- 256, 288, 320, 352, 384, 416, 448, 480, 512, 576, 640, 704, 768, 896, 1024
+ static const uint16_t subband_tab[33] = {
+ 0, 8, 16, 24, 32, 40, 48, 56,
+ 64, 80, 96, 112, 128, 144, 160, 176,
+ 192, 224, 256, 288, 320, 352, 384, 416,
+ 448, 480, 512, 576, 640, 704, 768, 896,
+ 1024
};
/* joint stereo related tables */
- static const float matrixCoeffs[8] = {0.0, 2.0, 2.0, 2.0, 0.0, 0.0, 1.0, 1.0};
+ static const float matrix_coeffs[8] = {
+ 0.0, 2.0, 2.0, 2.0, 0.0, 0.0, 1.0, 1.0
+ };
#endif /* AVCODEC_ATRAC3DATA_H */
* Interface to xvidcore for mpeg4 encoding
* Copyright (c) 2004 Adam Thayer <krevnik@comcast.net>
*
- * This file is part of Libav.
+ * This file is part of FFmpeg.
*
- * Libav is free software; you can redistribute it and/or
+ * 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.
*
- * Libav is distributed in the hope that it will be useful,
+ * 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 Libav; if not, write to the Free Software
+ * License along with FFmpeg; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include <xvid.h>
#include <unistd.h>
#include "avcodec.h"
+#include "internal.h"
+#include "libavutil/file.h"
#include "libavutil/cpu.h"
#include "libavutil/intreadwrite.h"
#include "libavutil/mathematics.h"
/* This is because we can safely prevent a buffer overflow */
log[0] = 0;
snprintf(log, BUFFER_REMAINING(log),
- "# avconv 2-pass log file, using xvid codec\n");
+ "# ffmpeg 2-pass log file, using xvid codec\n");
snprintf(BUFFER_CAT(log), BUFFER_REMAINING(log),
"# Do not modify. libxvidcore version: %d.%d.%d\n\n",
XVID_VERSION_MAJOR(XVID_VERSION),
}
}
- /**
- * Create the private context for the encoder.
- * All buffers are allocated, settings are loaded from the user,
- * and the encoder context created.
- *
- * @param avctx AVCodecContext pointer to context
- * @return Returns 0 on success, -1 on failure
- */
static av_cold int xvid_encode_init(AVCodecContext *avctx) {
int xerr, i;
int xvid_flags = avctx->flags;
xvid_enc_create_t xvid_enc_create = { 0 };
xvid_enc_plugin_t plugins[7];
- /* Bring in VOP flags from avconv command-line */
+ /* Bring in VOP flags from ffmpeg command-line */
x->vop_flags = XVID_VOP_HALFPEL; /* Bare minimum quality */
if( xvid_flags & CODEC_FLAG_4MV )
x->vop_flags |= XVID_VOP_INTER4V; /* Level 3 */
break;
}
- /* Bring in VOL flags from avconv command-line */
+ /* Bring in VOL flags from ffmpeg command-line */
x->vol_flags = 0;
if( xvid_flags & CODEC_FLAG_GMC ) {
x->vol_flags |= XVID_VOL_GMC;
rc2pass2.version = XVID_VERSION;
rc2pass2.bitrate = avctx->bit_rate;
- fd = ff_tempfile("xvidff.", &x->twopassfile);
+ fd = av_tempfile("xvidff.", &x->twopassfile, 0, avctx);
if( fd == -1 ) {
av_log(avctx, AV_LOG_ERROR,
"Xvid: Cannot write 2-pass pipe\n");
return 0;
}
- /**
- * Encode a single frame.
- *
- * @param avctx AVCodecContext pointer to context
- * @param frame Pointer to encoded frame buffer
- * @param buf_size Size of encoded frame buffer
- * @param data Pointer to AVFrame of unencoded frame
- * @return Returns 0 on success, -1 on failure
- */
static int xvid_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
const AVFrame *picture, int *got_packet)
{
xvid_enc_frame_t xvid_enc_frame = { 0 };
xvid_enc_stats_t xvid_enc_stats = { 0 };
- if (!user_packet &&
- (ret = av_new_packet(pkt, mb_width*mb_height*MAX_MB_BYTES + FF_MIN_BUFFER_SIZE)) < 0) {
- av_log(avctx, AV_LOG_ERROR, "Error getting output packet.\n");
+ if ((ret = ff_alloc_packet2(avctx, pkt, mb_width*mb_height*MAX_MB_BYTES + FF_MIN_BUFFER_SIZE)) < 0)
return ret;
- }
/* Start setting up the frame */
xvid_enc_frame.version = XVID_VERSION;
XVID_TYPE_AUTO;
/* Pixel aspect ratio setting */
- if (avctx->sample_aspect_ratio.num < 1 || avctx->sample_aspect_ratio.num > 255 ||
- avctx->sample_aspect_ratio.den < 1 || avctx->sample_aspect_ratio.den > 255) {
+ if (avctx->sample_aspect_ratio.num < 0 || avctx->sample_aspect_ratio.num > 255 ||
+ avctx->sample_aspect_ratio.den < 0 || avctx->sample_aspect_ratio.den > 255) {
av_log(avctx, AV_LOG_ERROR, "Invalid pixel aspect ratio %i/%i\n",
avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den);
return -1;
}
}
- /**
- * Destroy the private context for the encoder.
- * All buffers are freed, and the Xvid encoder context is destroyed.
- *
- * @param avctx AVCodecContext pointer to context
- * @return Returns 0, success guaranteed
- */
static av_cold int xvid_encode_close(AVCodecContext *avctx) {
struct xvid_context *x = avctx->priv_data;
if( x->twopassbuffer != NULL ) {
av_free(x->twopassbuffer);
av_free(x->old_twopassbuffer);
+ avctx->stats_out = NULL;
}
av_free(x->twopassfile);
av_free(x->intra_matrix);
return 0;
}
- /**
- * Xvid codec definition for libavcodec.
- */
AVCodec ff_libxvid_encoder = {
.name = "libxvid",
.type = AVMEDIA_TYPE_VIDEO,
/*
+ * Copyright (c) 2001 Fabrice Bellard
+ * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
*
- * This file is part of Libav.
+ * This file is part of FFmpeg.
*
- * Libav is free software; you can redistribute it and/or
+ * 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.
*
- * Libav is distributed in the hope that it will be useful,
+ * 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 Libav; if not, write to the Free Software
+ * License along with FFmpeg; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#define AV_CODEC_DEFAULT_BITRATE 200*1000
static const AVOption options[]={
-{"b", "set bitrate (in bits/s)", OFFSET(bit_rate), AV_OPT_TYPE_INT, {.i64 = AV_CODEC_DEFAULT_BITRATE }, INT_MIN, INT_MAX, V|A|E},
+{"b", "set bitrate (in bits/s)", OFFSET(bit_rate), AV_OPT_TYPE_INT, {.i64 = AV_CODEC_DEFAULT_BITRATE }, INT_MIN, INT_MAX, A|V|E},
+{"ab", "set bitrate (in bits/s)", OFFSET(bit_rate), AV_OPT_TYPE_INT, {.i64 = 128*1000 }, INT_MIN, INT_MAX, A|E},
{"bt", "Set video bitrate tolerance (in bits/s). In 1-pass mode, bitrate tolerance specifies how far "
"ratecontrol is willing to deviate from the target average bitrate value. This is not related "
"to min/max bitrate. Lowering tolerance too much has an adverse effect on quality.",
OFFSET(bit_rate_tolerance), AV_OPT_TYPE_INT, {.i64 = AV_CODEC_DEFAULT_BITRATE*20 }, 1, INT_MAX, V|E},
-{"flags", NULL, OFFSET(flags), AV_OPT_TYPE_FLAGS, {.i64 = DEFAULT }, 0, UINT_MAX, V|A|E|D, "flags"},
+{"flags", NULL, OFFSET(flags), AV_OPT_TYPE_FLAGS, {.i64 = DEFAULT }, 0, UINT_MAX, V|A|S|E|D, "flags"},
{"mv4", "use four motion vector by macroblock (mpeg4)", 0, AV_OPT_TYPE_CONST, {.i64 = CODEC_FLAG_4MV }, INT_MIN, INT_MAX, V|E, "flags"},
{"qpel", "use 1/4 pel motion compensation", 0, AV_OPT_TYPE_CONST, {.i64 = CODEC_FLAG_QPEL }, INT_MIN, INT_MAX, V|E, "flags"},
{"loop", "use loop filter", 0, AV_OPT_TYPE_CONST, {.i64 = CODEC_FLAG_LOOP_FILTER }, INT_MIN, INT_MAX, V|E, "flags"},
#endif
{"noout", "skip bitstream encoding", 0, AV_OPT_TYPE_CONST, {.i64 = CODEC_FLAG2_NO_OUTPUT }, INT_MIN, INT_MAX, V|E, "flags2"},
{"local_header", "place global headers at every keyframe instead of in extradata", 0, AV_OPT_TYPE_CONST, {.i64 = CODEC_FLAG2_LOCAL_HEADER }, INT_MIN, INT_MAX, V|E, "flags2"},
+{"chunks", "Frame data might be split into multiple chunks", 0, AV_OPT_TYPE_CONST, {.i64 = CODEC_FLAG2_CHUNKS }, INT_MIN, INT_MAX, V|D, "flags2"},
+{"showall", "Show all frames before the first keyframe", 0, AV_OPT_TYPE_CONST, {.i64 = CODEC_FLAG2_SHOW_ALL }, INT_MIN, INT_MAX, V|D, "flags2"},
#if FF_API_SUB_ID
{"sub_id", NULL, OFFSET(sub_id), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX},
#endif
OFFSET(qcompress), AV_OPT_TYPE_FLOAT, {.dbl = 0.5 }, -FLT_MAX, FLT_MAX, V|E},
{"qblur", "video quantizer scale blur (VBR)", OFFSET(qblur), AV_OPT_TYPE_FLOAT, {.dbl = 0.5 }, -1, FLT_MAX, V|E},
{"qmin", "min video quantizer scale (VBR)", OFFSET(qmin), AV_OPT_TYPE_INT, {.i64 = 2 }, -1, 69, V|E},
-{"qmax", "max video quantizer scale (VBR)", OFFSET(qmax), AV_OPT_TYPE_INT, {.i64 = 31 }, -1, 69, V|E},
+{"qmax", "max video quantizer scale (VBR)", OFFSET(qmax), AV_OPT_TYPE_INT, {.i64 = 31 }, -1, 1024, V|E},
{"qdiff", "max difference between the quantizer scale (VBR)", OFFSET(max_qdiff), AV_OPT_TYPE_INT, {.i64 = 3 }, INT_MIN, INT_MAX, V|E},
{"bf", "use 'frames' B frames", OFFSET(max_b_frames), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, -1, FF_MAX_B_FRAMES, V|E},
{"b_qfactor", "qp factor between p and b frames", OFFSET(b_quant_factor), AV_OPT_TYPE_FLOAT, {.dbl = 1.25 }, -FLT_MAX, FLT_MAX, V|E},
{"experimental", "allow non standardized experimental things", 0, AV_OPT_TYPE_CONST, {.i64 = FF_COMPLIANCE_EXPERIMENTAL }, INT_MIN, INT_MAX, V|D|E, "strict"},
{"b_qoffset", "qp offset between P and B frames", OFFSET(b_quant_offset), AV_OPT_TYPE_FLOAT, {.dbl = 1.25 }, -FLT_MAX, FLT_MAX, V|E},
{"err_detect", "set error detection flags", OFFSET(err_recognition), AV_OPT_TYPE_FLAGS, {.i64 = AV_EF_CRCCHECK }, INT_MIN, INT_MAX, A|V|D, "err_detect"},
-{"crccheck", "verify embedded CRCs", 0, AV_OPT_TYPE_CONST, {.i64 = AV_EF_CRCCHECK }, INT_MIN, INT_MAX, V|D, "err_detect"},
-{"bitstream", "detect bitstream specification deviations", 0, AV_OPT_TYPE_CONST, {.i64 = AV_EF_BITSTREAM }, INT_MIN, INT_MAX, V|D, "err_detect"},
-{"buffer", "detect improper bitstream length", 0, AV_OPT_TYPE_CONST, {.i64 = AV_EF_BUFFER }, INT_MIN, INT_MAX, V|D, "err_detect"},
-{"explode", "abort decoding on minor error detection", 0, AV_OPT_TYPE_CONST, {.i64 = AV_EF_EXPLODE }, INT_MIN, INT_MAX, V|D, "err_detect"},
+{"crccheck", "verify embedded CRCs", 0, AV_OPT_TYPE_CONST, {.i64 = AV_EF_CRCCHECK }, INT_MIN, INT_MAX, A|V|D, "err_detect"},
+{"bitstream", "detect bitstream specification deviations", 0, AV_OPT_TYPE_CONST, {.i64 = AV_EF_BITSTREAM }, INT_MIN, INT_MAX, A|V|D, "err_detect"},
+{"buffer", "detect improper bitstream length", 0, AV_OPT_TYPE_CONST, {.i64 = AV_EF_BUFFER }, INT_MIN, INT_MAX, A|V|D, "err_detect"},
+{"explode", "abort decoding on minor error detection", 0, AV_OPT_TYPE_CONST, {.i64 = AV_EF_EXPLODE }, INT_MIN, INT_MAX, A|V|D, "err_detect"},
+{"careful", "consider things that violate the spec and have not been seen in the wild as errors", 0, AV_OPT_TYPE_CONST, {.i64 = AV_EF_CAREFUL }, INT_MIN, INT_MAX, A|V|D, "err_detect"},
+{"compliant", "consider all spec non compliancies as errors", 0, AV_OPT_TYPE_CONST, {.i64 = AV_EF_COMPLIANT }, INT_MIN, INT_MAX, A|V|D, "err_detect"},
+{"aggressive", "consider things that a sane encoder should not do as an error", 0, AV_OPT_TYPE_CONST, {.i64 = AV_EF_AGGRESSIVE }, INT_MIN, INT_MAX, A|V|D, "err_detect"},
{"has_b_frames", NULL, OFFSET(has_b_frames), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX},
{"block_align", NULL, OFFSET(block_align), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX},
{"mpeg_quant", "use MPEG quantizers instead of H.263", OFFSET(mpeg_quant), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX, V|E},
- {"stats_out", NULL, OFFSET(stats_out), AV_OPT_TYPE_STRING, {.str = NULL}, CHAR_MIN, CHAR_MAX},
{"qsquish", "how to keep quantizer between qmin and qmax (0 = clip, 1 = use differentiable function)", OFFSET(rc_qsquish), AV_OPT_TYPE_FLOAT, {.dbl = DEFAULT }, 0, 99, V|E},
{"rc_qmod_amp", "experimental quantizer modulation", OFFSET(rc_qmod_amp), AV_OPT_TYPE_FLOAT, {.dbl = DEFAULT }, -FLT_MAX, FLT_MAX, V|E},
{"rc_qmod_freq", "experimental quantizer modulation", OFFSET(rc_qmod_freq), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX, V|E},
{"int", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_IDCT_INT }, INT_MIN, INT_MAX, V|E|D, "idct"},
{"simple", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_IDCT_SIMPLE }, INT_MIN, INT_MAX, V|E|D, "idct"},
{"simplemmx", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_IDCT_SIMPLEMMX }, INT_MIN, INT_MAX, V|E|D, "idct"},
+{"libmpeg2mmx", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_IDCT_LIBMPEG2MMX }, INT_MIN, INT_MAX, V|E|D, "idct"},
#if FF_API_MMI
{"mmi", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_IDCT_MMI }, INT_MIN, INT_MAX, V|E|D, "idct"},
#endif
{"dts_hd_ma", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_PROFILE_DTS_HD_MA }, INT_MIN, INT_MAX, A|E, "profile"},
{"level", NULL, OFFSET(level), AV_OPT_TYPE_INT, {.i64 = FF_LEVEL_UNKNOWN }, INT_MIN, INT_MAX, V|A|E, "level"},
{"unknown", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_LEVEL_UNKNOWN }, INT_MIN, INT_MAX, V|A|E, "level"},
+{"lowres", "decode at 1= 1/2, 2=1/4, 3=1/8 resolutions", OFFSET(lowres), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, INT_MAX, V|A|D},
{"skip_threshold", "frame skip threshold", OFFSET(frame_skip_threshold), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX, V|E},
{"skip_factor", "frame skip factor", OFFSET(frame_skip_factor), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX, V|E},
{"skip_exp", "frame skip exponent", OFFSET(frame_skip_exp), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX, V|E},
{"all" , NULL, 0, AV_OPT_TYPE_CONST, {.i64 = AVDISCARD_ALL }, INT_MIN, INT_MAX, V|D, "avdiscard"},
{"bidir_refine", "refine the two motion vectors used in bidirectional macroblocks", OFFSET(bidir_refine), AV_OPT_TYPE_INT, {.i64 = 1 }, 0, 4, V|E},
{"brd_scale", "downscales frames for dynamic B-frame decision", OFFSET(brd_scale), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, 0, 10, V|E},
-{"keyint_min", "minimum interval between IDR-frames (x264)", OFFSET(keyint_min), AV_OPT_TYPE_INT, {.i64 = 25 }, INT_MIN, INT_MAX, V|E},
+{"keyint_min", "minimum interval between IDR-frames", OFFSET(keyint_min), AV_OPT_TYPE_INT, {.i64 = 25 }, INT_MIN, INT_MAX, V|E},
{"refs", "reference frames to consider for motion compensation", OFFSET(refs), AV_OPT_TYPE_INT, {.i64 = 1 }, INT_MIN, INT_MAX, V|E},
{"chromaoffset", "chroma qp offset from luma", OFFSET(chromaoffset), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX, V|E},
{"trellis", "rate-distortion optimal quantization", OFFSET(trellis), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX, V|A|E},
{"bits_per_raw_sample", NULL, OFFSET(bits_per_raw_sample), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX},
{"channel_layout", NULL, OFFSET(channel_layout), AV_OPT_TYPE_INT64, {.i64 = DEFAULT }, 0, INT64_MAX, A|E|D, "channel_layout"},
{"request_channel_layout", NULL, OFFSET(request_channel_layout), AV_OPT_TYPE_INT64, {.i64 = DEFAULT }, 0, INT64_MAX, A|D, "request_channel_layout"},
-{"rc_max_vbv_use", NULL, OFFSET(rc_max_available_vbv_use), AV_OPT_TYPE_FLOAT, {.dbl = 1.0/3 }, 0.0, FLT_MAX, V|E},
+{"rc_max_vbv_use", NULL, OFFSET(rc_max_available_vbv_use), AV_OPT_TYPE_FLOAT, {.dbl = 0 }, 0.0, FLT_MAX, V|E},
{"rc_min_vbv_use", NULL, OFFSET(rc_min_vbv_overflow_use), AV_OPT_TYPE_FLOAT, {.dbl = 3 }, 0.0, FLT_MAX, V|E},
{"ticks_per_frame", NULL, OFFSET(ticks_per_frame), AV_OPT_TYPE_INT, {.i64 = 1 }, 1, INT_MAX, A|V|E|D},
{"color_primaries", NULL, OFFSET(color_primaries), AV_OPT_TYPE_INT, {.i64 = AVCOL_PRI_UNSPECIFIED }, 1, AVCOL_PRI_NB-1, V|E|D},
{"em", "Emergency", 0, AV_OPT_TYPE_CONST, {.i64 = AV_AUDIO_SERVICE_TYPE_EMERGENCY }, INT_MIN, INT_MAX, A|E, "audio_service_type"},
{"vo", "Voice Over", 0, AV_OPT_TYPE_CONST, {.i64 = AV_AUDIO_SERVICE_TYPE_VOICE_OVER }, INT_MIN, INT_MAX, A|E, "audio_service_type"},
{"ka", "Karaoke", 0, AV_OPT_TYPE_CONST, {.i64 = AV_AUDIO_SERVICE_TYPE_KARAOKE }, INT_MIN, INT_MAX, A|E, "audio_service_type"},
-{"request_sample_fmt", NULL, OFFSET(request_sample_fmt), AV_OPT_TYPE_INT, {.i64 = AV_SAMPLE_FMT_NONE }, AV_SAMPLE_FMT_NONE, AV_SAMPLE_FMT_NB-1, A|D, "request_sample_fmt"},
+{"request_sample_fmt", "sample format audio decoders should prefer", OFFSET(request_sample_fmt), AV_OPT_TYPE_INT, {.i64 = AV_SAMPLE_FMT_NONE }, AV_SAMPLE_FMT_NONE, AV_SAMPLE_FMT_NB-1, A|D, "request_sample_fmt"},
{"u8" , "8-bit unsigned integer", 0, AV_OPT_TYPE_CONST, {.i64 = AV_SAMPLE_FMT_U8 }, INT_MIN, INT_MAX, A|D, "request_sample_fmt"},
{"s16", "16-bit signed integer", 0, AV_OPT_TYPE_CONST, {.i64 = AV_SAMPLE_FMT_S16 }, INT_MIN, INT_MAX, A|D, "request_sample_fmt"},
{"s32", "32-bit signed integer", 0, AV_OPT_TYPE_CONST, {.i64 = AV_SAMPLE_FMT_S32 }, INT_MIN, INT_MAX, A|D, "request_sample_fmt"},
{"s32p", "32-bit signed integer planar", 0, AV_OPT_TYPE_CONST, {.i64 = AV_SAMPLE_FMT_S32P }, INT_MIN, INT_MAX, A|D, "request_sample_fmt"},
{"fltp", "32-bit float planar", 0, AV_OPT_TYPE_CONST, {.i64 = AV_SAMPLE_FMT_FLTP }, INT_MIN, INT_MAX, A|D, "request_sample_fmt"},
{"dblp", "64-bit double planar", 0, AV_OPT_TYPE_CONST, {.i64 = AV_SAMPLE_FMT_DBLP }, INT_MIN, INT_MAX, A|D, "request_sample_fmt"},
+{"pkt_timebase", NULL, OFFSET(pkt_timebase), AV_OPT_TYPE_RATIONAL, {.dbl = 0 }, 0, INT_MAX, 0},
{NULL},
};
* PCM codecs
* Copyright (c) 2001 Fabrice Bellard
*
- * This file is part of Libav.
+ * This file is part of FFmpeg.
*
- * Libav is free software; you can redistribute it and/or
+ * 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.
*
- * Libav is distributed in the hope that it will be useful,
+ * 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 Libav; if not, write to the Free Software
+ * License along with FFmpeg; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
n = frame->nb_samples * avctx->channels;
samples = (const short *)frame->data[0];
- if ((ret = ff_alloc_packet(avpkt, n * sample_size))) {
- av_log(avctx, AV_LOG_ERROR, "Error getting output packet\n");
+ if ((ret = ff_alloc_packet2(avctx, avpkt, n * sample_size)))
return ret;
- }
dst = avpkt->data;
switch (avctx->codec->id) {
if (AV_CODEC_ID_PCM_DVD == avctx->codec_id) {
if (avctx->bits_per_coded_sample != 20 &&
avctx->bits_per_coded_sample != 24) {
- av_log(avctx, AV_LOG_ERROR, "PCM DVD unsupported sample depth\n");
+ av_log(avctx, AV_LOG_ERROR,
+ "PCM DVD unsupported sample depth %i\n",
+ avctx->bits_per_coded_sample);
return AVERROR(EINVAL);
}
/* 2 samples are interleaved per block in PCM_DVD */
if (n && buf_size % n) {
if (buf_size < n) {
- av_log(avctx, AV_LOG_ERROR, "invalid PCM packet\n");
- return -1;
+ av_log(avctx, AV_LOG_ERROR,
+ "Invalid PCM packet, data has size %d but at least a size of %d was expected\n",
+ buf_size, n);
+ return AVERROR_INVALIDDATA;
} else
buf_size -= buf_size % n;
}
break;
case AV_CODEC_ID_PCM_S16LE_PLANAR:
{
- const uint8_t *src2[MAX_CHANNELS];
+ int i;
n /= avctx->channels;
- for (c = 0; c < avctx->channels; c++)
- src2[c] = &src[c * n * 2];
- for (; n > 0; n--)
- for (c = 0; c < avctx->channels; c++) {
- AV_WN16A(samples, bytestream_get_le16(&src2[c]));
+ for (c = 0; c < avctx->channels; c++) {
+ samples = s->frame.data[c];
+ for (i = n; i > 0; i--) {
+ AV_WN16A(samples, bytestream_get_le16(&src));
samples += 2;
}
+ }
break;
}
case AV_CODEC_ID_PCM_U16LE:
return buf_size;
}
- #if CONFIG_ENCODERS
- #define PCM_ENCODER(id_, sample_fmt_, name_, long_name_) \
+ #define PCM_ENCODER_0(id_, sample_fmt_, name_, long_name_)
+ #define PCM_ENCODER_1(id_, sample_fmt_, name_, long_name_) \
AVCodec ff_ ## name_ ## _encoder = { \
.name = #name_, \
.type = AVMEDIA_TYPE_AUDIO, \
- .id = id_, \
+ .id = AV_CODEC_ID_ ## id_, \
.init = pcm_encode_init, \
.encode2 = pcm_encode_frame, \
.close = pcm_encode_close, \
AV_SAMPLE_FMT_NONE }, \
.long_name = NULL_IF_CONFIG_SMALL(long_name_), \
}
- #else
- #define PCM_ENCODER(id, sample_fmt_, name, long_name_)
- #endif
- #if CONFIG_DECODERS
- #define PCM_DECODER(id_, sample_fmt_, name_, long_name_) \
+ #define PCM_ENCODER_2(cf, id, sample_fmt, name, long_name) \
+ PCM_ENCODER_ ## cf(id, sample_fmt, name, long_name)
+ #define PCM_ENCODER_3(cf, id, sample_fmt, name, long_name) \
+ PCM_ENCODER_2(cf, id, sample_fmt, name, long_name)
+ #define PCM_ENCODER(id, sample_fmt, name, long_name) \
+ PCM_ENCODER_3(CONFIG_ ## id ## _ENCODER, id, sample_fmt, name, long_name)
+
+ #define PCM_DECODER_0(id, sample_fmt, name, long_name)
+ #define PCM_DECODER_1(id_, sample_fmt_, name_, long_name_) \
AVCodec ff_ ## name_ ## _decoder = { \
.name = #name_, \
.type = AVMEDIA_TYPE_AUDIO, \
- .id = id_, \
+ .id = AV_CODEC_ID_ ## id_, \
.priv_data_size = sizeof(PCMDecode), \
.init = pcm_decode_init, \
.decode = pcm_decode_frame, \
AV_SAMPLE_FMT_NONE }, \
.long_name = NULL_IF_CONFIG_SMALL(long_name_), \
}
- #else
- #define PCM_DECODER(id, sample_fmt_, name, long_name_)
- #endif
+
+ #define PCM_DECODER_2(cf, id, sample_fmt, name, long_name) \
+ PCM_DECODER_ ## cf(id, sample_fmt, name, long_name)
+ #define PCM_DECODER_3(cf, id, sample_fmt, name, long_name) \
+ PCM_DECODER_2(cf, id, sample_fmt, name, long_name)
+ #define PCM_DECODER(id, sample_fmt, name, long_name) \
+ PCM_DECODER_3(CONFIG_ ## id ## _DECODER, id, sample_fmt, name, long_name)
#define PCM_CODEC(id, sample_fmt_, name, long_name_) \
PCM_ENCODER(id, sample_fmt_, name, long_name_); \
PCM_DECODER(id, sample_fmt_, name, long_name_)
/* Note: Do not forget to add new entries to the Makefile as well. */
- PCM_CODEC (AV_CODEC_ID_PCM_ALAW, AV_SAMPLE_FMT_S16, pcm_alaw, "PCM A-law / G.711 A-law");
- PCM_DECODER(AV_CODEC_ID_PCM_DVD, AV_SAMPLE_FMT_S32, pcm_dvd, "PCM signed 20|24-bit big-endian");
- PCM_CODEC (AV_CODEC_ID_PCM_F32BE, AV_SAMPLE_FMT_FLT, pcm_f32be, "PCM 32-bit floating point big-endian");
- PCM_CODEC (AV_CODEC_ID_PCM_F32LE, AV_SAMPLE_FMT_FLT, pcm_f32le, "PCM 32-bit floating point little-endian");
- PCM_CODEC (AV_CODEC_ID_PCM_F64BE, AV_SAMPLE_FMT_DBL, pcm_f64be, "PCM 64-bit floating point big-endian");
- PCM_CODEC (AV_CODEC_ID_PCM_F64LE, AV_SAMPLE_FMT_DBL, pcm_f64le, "PCM 64-bit floating point little-endian");
- PCM_DECODER(AV_CODEC_ID_PCM_LXF, AV_SAMPLE_FMT_S32P,pcm_lxf, "PCM signed 20-bit little-endian planar");
- PCM_CODEC (AV_CODEC_ID_PCM_MULAW, AV_SAMPLE_FMT_S16, pcm_mulaw, "PCM mu-law / G.711 mu-law");
- PCM_CODEC (AV_CODEC_ID_PCM_S8, AV_SAMPLE_FMT_U8, pcm_s8, "PCM signed 8-bit");
- PCM_CODEC (AV_CODEC_ID_PCM_S16BE, AV_SAMPLE_FMT_S16, pcm_s16be, "PCM signed 16-bit big-endian");
- PCM_CODEC (AV_CODEC_ID_PCM_S16LE, AV_SAMPLE_FMT_S16, pcm_s16le, "PCM signed 16-bit little-endian");
- PCM_DECODER(AV_CODEC_ID_PCM_S16LE_PLANAR, AV_SAMPLE_FMT_S16P,pcm_s16le_planar, "PCM 16-bit little-endian planar");
- PCM_CODEC (AV_CODEC_ID_PCM_S24BE, AV_SAMPLE_FMT_S32, pcm_s24be, "PCM signed 24-bit big-endian");
- PCM_CODEC (AV_CODEC_ID_PCM_S24DAUD, AV_SAMPLE_FMT_S16, pcm_s24daud, "PCM D-Cinema audio signed 24-bit");
- PCM_CODEC (AV_CODEC_ID_PCM_S24LE, AV_SAMPLE_FMT_S32, pcm_s24le, "PCM signed 24-bit little-endian");
- PCM_CODEC (AV_CODEC_ID_PCM_S32BE, AV_SAMPLE_FMT_S32, pcm_s32be, "PCM signed 32-bit big-endian");
- PCM_CODEC (AV_CODEC_ID_PCM_S32LE, AV_SAMPLE_FMT_S32, pcm_s32le, "PCM signed 32-bit little-endian");
- PCM_CODEC (AV_CODEC_ID_PCM_U8, AV_SAMPLE_FMT_U8, pcm_u8, "PCM unsigned 8-bit");
- PCM_CODEC (AV_CODEC_ID_PCM_U16BE, AV_SAMPLE_FMT_S16, pcm_u16be, "PCM unsigned 16-bit big-endian");
- PCM_CODEC (AV_CODEC_ID_PCM_U16LE, AV_SAMPLE_FMT_S16, pcm_u16le, "PCM unsigned 16-bit little-endian");
- PCM_CODEC (AV_CODEC_ID_PCM_U24BE, AV_SAMPLE_FMT_S32, pcm_u24be, "PCM unsigned 24-bit big-endian");
- PCM_CODEC (AV_CODEC_ID_PCM_U24LE, AV_SAMPLE_FMT_S32, pcm_u24le, "PCM unsigned 24-bit little-endian");
- PCM_CODEC (AV_CODEC_ID_PCM_U32BE, AV_SAMPLE_FMT_S32, pcm_u32be, "PCM unsigned 32-bit big-endian");
- PCM_CODEC (AV_CODEC_ID_PCM_U32LE, AV_SAMPLE_FMT_S32, pcm_u32le, "PCM unsigned 32-bit little-endian");
- PCM_DECODER(AV_CODEC_ID_PCM_ZORK, AV_SAMPLE_FMT_U8, pcm_zork, "PCM Zork");
-PCM_CODEC (PCM_ALAW, AV_SAMPLE_FMT_S16, pcm_alaw, "PCM A-law");
++PCM_CODEC (PCM_ALAW, AV_SAMPLE_FMT_S16, pcm_alaw, "PCM A-law / G.711 A-law");
+ PCM_DECODER(PCM_DVD, AV_SAMPLE_FMT_S32, pcm_dvd, "PCM signed 20|24-bit big-endian");
+ PCM_CODEC (PCM_F32BE, AV_SAMPLE_FMT_FLT, pcm_f32be, "PCM 32-bit floating point big-endian");
+ PCM_CODEC (PCM_F32LE, AV_SAMPLE_FMT_FLT, pcm_f32le, "PCM 32-bit floating point little-endian");
+ PCM_CODEC (PCM_F64BE, AV_SAMPLE_FMT_DBL, pcm_f64be, "PCM 64-bit floating point big-endian");
+ PCM_CODEC (PCM_F64LE, AV_SAMPLE_FMT_DBL, pcm_f64le, "PCM 64-bit floating point little-endian");
-PCM_DECODER(PCM_LXF, AV_SAMPLE_FMT_S32P, pcm_lxf, "PCM signed 20-bit little-endian planar");
-PCM_CODEC (PCM_MULAW, AV_SAMPLE_FMT_S16, pcm_mulaw, "PCM mu-law");
++PCM_DECODER(PCM_LXF, AV_SAMPLE_FMT_S32P,pcm_lxf, "PCM signed 20-bit little-endian planar");
++PCM_CODEC (PCM_MULAW, AV_SAMPLE_FMT_S16, pcm_mulaw, "PCM mu-law / G.711 mu-law");
+ PCM_CODEC (PCM_S8, AV_SAMPLE_FMT_U8, pcm_s8, "PCM signed 8-bit");
+ PCM_CODEC (PCM_S16BE, AV_SAMPLE_FMT_S16, pcm_s16be, "PCM signed 16-bit big-endian");
+ PCM_CODEC (PCM_S16LE, AV_SAMPLE_FMT_S16, pcm_s16le, "PCM signed 16-bit little-endian");
-PCM_DECODER(PCM_S16LE_PLANAR, AV_SAMPLE_FMT_S16, pcm_s16le_planar, "PCM 16-bit little-endian planar");
++PCM_DECODER(PCM_S16LE_PLANAR, AV_SAMPLE_FMT_S16P,pcm_s16le_planar, "PCM 16-bit little-endian planar");
+ PCM_CODEC (PCM_S24BE, AV_SAMPLE_FMT_S32, pcm_s24be, "PCM signed 24-bit big-endian");
+ PCM_CODEC (PCM_S24DAUD, AV_SAMPLE_FMT_S16, pcm_s24daud, "PCM D-Cinema audio signed 24-bit");
+ PCM_CODEC (PCM_S24LE, AV_SAMPLE_FMT_S32, pcm_s24le, "PCM signed 24-bit little-endian");
+ PCM_CODEC (PCM_S32BE, AV_SAMPLE_FMT_S32, pcm_s32be, "PCM signed 32-bit big-endian");
+ PCM_CODEC (PCM_S32LE, AV_SAMPLE_FMT_S32, pcm_s32le, "PCM signed 32-bit little-endian");
+ PCM_CODEC (PCM_U8, AV_SAMPLE_FMT_U8, pcm_u8, "PCM unsigned 8-bit");
+ PCM_CODEC (PCM_U16BE, AV_SAMPLE_FMT_S16, pcm_u16be, "PCM unsigned 16-bit big-endian");
+ PCM_CODEC (PCM_U16LE, AV_SAMPLE_FMT_S16, pcm_u16le, "PCM unsigned 16-bit little-endian");
+ PCM_CODEC (PCM_U24BE, AV_SAMPLE_FMT_S32, pcm_u24be, "PCM unsigned 24-bit big-endian");
+ PCM_CODEC (PCM_U24LE, AV_SAMPLE_FMT_S32, pcm_u24le, "PCM unsigned 24-bit little-endian");
+ PCM_CODEC (PCM_U32BE, AV_SAMPLE_FMT_S32, pcm_u32be, "PCM unsigned 32-bit big-endian");
+ PCM_CODEC (PCM_U32LE, AV_SAMPLE_FMT_S32, pcm_u32le, "PCM unsigned 32-bit little-endian");
+ PCM_DECODER(PCM_ZORK, AV_SAMPLE_FMT_U8, pcm_zork, "PCM Zork");
+
projects / ffmpeg / commitdiff