*/
/**
- * @file cook.c
+ * @file libavcodec/cook.c
* Cook compatible decoder. Bastardization of the G.722.1 standard.
* This decoder handles RealNetworks, RealAudio G2 data.
* Cook is identified by the codec name cook in RM files.
#include <stddef.h>
#include <stdio.h>
+#include "libavutil/lfg.h"
+#include "libavutil/random_seed.h"
#include "avcodec.h"
-#include "bitstream.h"
+#include "get_bits.h"
#include "dsputil.h"
#include "bytestream.h"
-#include "random.h"
#include "cookdata.h"
#define MC_COOK 0x2000000 //multichannel Cook, not supported
#define SUBBAND_SIZE 20
+#define MAX_SUBPACKETS 5
//#define COOKDEBUG
typedef struct {
int *previous;
} cook_gains;
-typedef struct {
+typedef struct cook {
+ /*
+ * The following 5 functions provide the lowlevel arithmetic on
+ * the internal audio buffers.
+ */
+ void (* scalar_dequant)(struct cook *q, int index, int quant_index,
+ int* subband_coef_index, int* subband_coef_sign,
+ float* mlt_p);
+
+ void (* decouple) (struct cook *q,
+ int subband,
+ float f1, float f2,
+ float *decode_buffer,
+ float *mlt_buffer1, float *mlt_buffer2);
+
+ void (* imlt_window) (struct cook *q, float *buffer1,
+ cook_gains *gains_ptr, float *previous_buffer);
+
+ void (* interpolate) (struct cook *q, float* buffer,
+ int gain_index, int gain_index_next);
+
+ void (* saturate_output) (struct cook *q, int chan, int16_t *out);
+
+ AVCodecContext* avctx;
GetBitContext gb;
/* stream data */
int nb_channels;
int bits_per_subpacket;
int cookversion;
/* states */
- AVRandomState random_state;
+ AVLFG random_state;
/* transform data */
MDCTContext mdct_ctx;
- DECLARE_ALIGNED_16(FFTSample, mdct_tmp[1024]); /* temporary storage for imlt */
float* mlt_window;
/* gain buffers */
/* generatable tables and related variables */
int gain_size_factor;
float gain_table[23];
- float pow2tab[127];
- float rootpow2tab[127];
/* data buffers */
float decode_buffer_1[1024];
float decode_buffer_2[1024];
float decode_buffer_0[1060]; /* static allocation for joint decode */
+
+ const float *cplscales[5];
} COOKContext;
+static float pow2tab[127];
+static float rootpow2tab[127];
+
/* debug functions */
#ifdef COOKDEBUG
/*************** init functions ***************/
/* table generator */
-static void init_pow2table(COOKContext *q){
- int i;
- q->pow2tab[63] = 1.0;
- for (i=1 ; i<64 ; i++){
- q->pow2tab[63+i]=(float)((uint64_t)1<<i);
- q->pow2tab[63-i]=1.0/(float)((uint64_t)1<<i);
- }
-}
-
-/* table generator */
-static void init_rootpow2table(COOKContext *q){
+static av_cold void init_pow2table(void){
int i;
- q->rootpow2tab[63] = 1.0;
- for (i=1 ; i<64 ; i++){
- q->rootpow2tab[63+i]=sqrt((float)((uint64_t)1<<i));
- q->rootpow2tab[63-i]=sqrt(1.0/(float)((uint64_t)1<<i));
+ for (i=-63 ; i<64 ; i++){
+ pow2tab[63+i]= pow(2, i);
+ rootpow2tab[63+i]=sqrt(pow(2, i));
}
}
/* table generator */
-static void init_gain_table(COOKContext *q) {
+static av_cold void init_gain_table(COOKContext *q) {
int i;
q->gain_size_factor = q->samples_per_channel/8;
for (i=0 ; i<23 ; i++) {
- q->gain_table[i] = pow((double)q->pow2tab[i+52] ,
+ q->gain_table[i] = pow(pow2tab[i+52] ,
(1.0/(double)q->gain_size_factor));
}
}
-static int init_cook_vlc_tables(COOKContext *q) {
+static av_cold int init_cook_vlc_tables(COOKContext *q) {
int i, result;
result = 0;
envelope_quant_index_huffbits[i], 1, 1,
envelope_quant_index_huffcodes[i], 2, 2, 0);
}
- av_log(NULL,AV_LOG_DEBUG,"sqvh VLC init\n");
+ av_log(q->avctx,AV_LOG_DEBUG,"sqvh VLC init\n");
for (i=0 ; i<7 ; i++) {
result |= init_vlc (&q->sqvh[i], vhvlcsize_tab[i], vhsize_tab[i],
cvh_huffbits[i], 1, 1,
result |= init_vlc (&q->ccpl, 6, (1<<q->js_vlc_bits)-1,
ccpl_huffbits[q->js_vlc_bits-2], 1, 1,
ccpl_huffcodes[q->js_vlc_bits-2], 2, 2, 0);
- av_log(NULL,AV_LOG_DEBUG,"Joint-stereo VLC used.\n");
+ av_log(q->avctx,AV_LOG_DEBUG,"Joint-stereo VLC used.\n");
}
- av_log(NULL,AV_LOG_DEBUG,"VLC tables initialized.\n");
+ av_log(q->avctx,AV_LOG_DEBUG,"VLC tables initialized.\n");
return result;
}
-static int init_cook_mlt(COOKContext *q) {
+static av_cold int init_cook_mlt(COOKContext *q) {
int j;
- float alpha;
int mlt_size = q->samples_per_channel;
if ((q->mlt_window = av_malloc(sizeof(float)*mlt_size)) == 0)
return -1;
/* Initialize the MLT window: simple sine window. */
- alpha = M_PI / (2.0 * (float)mlt_size);
+ ff_sine_window_init(q->mlt_window, mlt_size);
for(j=0 ; j<mlt_size ; j++)
- q->mlt_window[j] = sin((j + 0.5) * alpha) * sqrt(2.0 / q->samples_per_channel);
+ q->mlt_window[j] *= sqrt(2.0 / q->samples_per_channel);
/* Initialize the MDCT. */
if (ff_mdct_init(&q->mdct_ctx, av_log2(mlt_size)+1, 1)) {
av_free(q->mlt_window);
return -1;
}
- av_log(NULL,AV_LOG_DEBUG,"MDCT initialized, order = %d.\n",
+ av_log(q->avctx,AV_LOG_DEBUG,"MDCT initialized, order = %d.\n",
av_log2(mlt_size)+1);
return 0;
}
+static const float *maybe_reformat_buffer32 (COOKContext *q, const float *ptr, int n)
+{
+ if (1)
+ return ptr;
+}
+
+static av_cold void init_cplscales_table (COOKContext *q) {
+ int i;
+ for (i=0;i<5;i++)
+ q->cplscales[i] = maybe_reformat_buffer32 (q, cplscales[i], (1<<(i+2))-1);
+}
+
/*************** init functions end ***********/
/**
* Why? No idea, some checksum/error detection method maybe.
*
* Out buffer size: extra bytes are needed to cope with
- * padding/missalignment.
+ * padding/misalignment.
* Subpackets passed to the decoder can contain two, consecutive
* half-subpackets, of identical but arbitrary size.
* 1234 1234 1234 1234 extraA extraB
#define DECODE_BYTES_PAD1(bytes) (3 - ((bytes)+3) % 4)
#define DECODE_BYTES_PAD2(bytes) ((bytes) % 4 + DECODE_BYTES_PAD1(2 * (bytes)))
-static inline int decode_bytes(uint8_t* inbuffer, uint8_t* out, int bytes){
+static inline int decode_bytes(const uint8_t* inbuffer, uint8_t* out, int bytes){
int i, off;
uint32_t c;
- uint32_t* buf;
+ const uint32_t* buf;
uint32_t* obuf = (uint32_t*) out;
/* FIXME: 64 bit platforms would be able to do 64 bits at a time.
* I'm too lazy though, should be something like
* (int64_t)out[i] = 0x37c511f237c511f2^be2me_64(int64_t)in[i]);
* Buffer alignment needs to be checked. */
- off = (int)((long)inbuffer & 3);
- buf = (uint32_t*) (inbuffer - off);
+ off = (intptr_t)inbuffer & 3;
+ buf = (const uint32_t*) (inbuffer - off);
c = be2me_32((0x37c511f2 >> (off*8)) | (0x37c511f2 << (32-(off*8))));
bytes += 3 + off;
for (i = 0; i < bytes/4; i++)
* Cook uninit
*/
-static int cook_decode_close(AVCodecContext *avctx)
+static av_cold int cook_decode_close(AVCodecContext *avctx)
{
int i;
COOKContext *q = avctx->priv_data;
free_vlc(&q->ccpl);
}
- av_log(NULL,AV_LOG_DEBUG,"Memory deallocated.\n");
+ av_log(avctx,AV_LOG_DEBUG,"Memory deallocated.\n");
return 0;
}
* Fill the gain array for the timedomain quantization.
*
* @param q pointer to the COOKContext
- * @param gaininfo[9] array of gain indices
+ * @param gaininfo[9] array of gain indexes
*/
static void decode_gain_info(GetBitContext *gb, int *gaininfo)
if(bits_left > q->samples_per_channel) {
bits_left = q->samples_per_channel +
((bits_left - q->samples_per_channel)*5)/8;
- //av_log(NULL, AV_LOG_ERROR, "bits_left = %d\n",bits_left);
+ //av_log(q->avctx, AV_LOG_ERROR, "bits_left = %d\n",bits_left);
}
memset(&exp_index1,0,102*sizeof(int));
* @param mlt_p pointer into the mlt buffer
*/
-static void scalar_dequant(COOKContext *q, int index, int quant_index,
+static void scalar_dequant_float(COOKContext *q, int index, int quant_index,
int* subband_coef_index, int* subband_coef_sign,
float* mlt_p){
int i;
} else {
/* noise coding if subband_coef_index[i] == 0 */
f1 = dither_tab[index];
- if (av_random(&q->random_state) < 0x80000000) f1 = -f1;
+ if (av_lfg_get(&q->random_state) < 0x80000000) f1 = -f1;
}
- mlt_p[i] = f1 * q->rootpow2tab[quant_index+63];
+ mlt_p[i] = f1 * rootpow2tab[quant_index+63];
}
}
/**
for(j=0 ; j<q->total_subbands ; j++) category[band+j]=7;
}
}
- if(index==7) {
+ if(index>=7) {
memset(subband_coef_index, 0, sizeof(subband_coef_index));
memset(subband_coef_sign, 0, sizeof(subband_coef_sign));
}
- scalar_dequant(q, index, quant_index_table[band],
- subband_coef_index, subband_coef_sign,
- &mlt_buffer[band * SUBBAND_SIZE]);
+ q->scalar_dequant(q, index, quant_index_table[band],
+ subband_coef_index, subband_coef_sign,
+ &mlt_buffer[band * SUBBAND_SIZE]);
}
if(q->total_subbands*SUBBAND_SIZE >= q->samples_per_channel){
* @param gain_index_next index for the next block multiplier
*/
-static void interpolate(COOKContext *q, float* buffer,
+static void interpolate_float(COOKContext *q, float* buffer,
int gain_index, int gain_index_next){
int i;
float fc1, fc2;
- fc1 = q->pow2tab[gain_index+63];
+ fc1 = pow2tab[gain_index+63];
if(gain_index == gain_index_next){ //static gain
for(i=0 ; i<q->gain_size_factor ; i++){
static void imlt_window_float (COOKContext *q, float *buffer1,
cook_gains *gains_ptr, float *previous_buffer)
{
- const float fc = q->pow2tab[gains_ptr->previous[0] + 63];
+ const float fc = pow2tab[gains_ptr->previous[0] + 63];
int i;
/* The weird thing here, is that the two halves of the time domain
* buffer are swapped. Also, the newest data, that we save away for
int i;
/* Inverse modified discrete cosine transform */
- q->mdct_ctx.fft.imdct_calc(&q->mdct_ctx, q->mono_mdct_output,
- inbuffer, q->mdct_tmp);
+ ff_imdct_calc(&q->mdct_ctx, q->mono_mdct_output, inbuffer);
- imlt_window_float (q, buffer1, gains_ptr, previous_buffer);
+ q->imlt_window (q, buffer1, gains_ptr, previous_buffer);
/* Apply gain profile */
for (i = 0; i < 8; i++) {
if (gains_ptr->now[i] || gains_ptr->now[i + 1])
- interpolate(q, &buffer1[q->gain_size_factor * i],
- gains_ptr->now[i], gains_ptr->now[i + 1]);
+ q->interpolate(q, &buffer1[q->gain_size_factor * i],
+ gains_ptr->now[i], gains_ptr->now[i + 1]);
}
/* Save away the current to be previous block. */
int i,j;
int decouple_tab[SUBBAND_SIZE];
float *decode_buffer = q->decode_buffer_0;
- int idx, cpl_tmp,tmp_idx;
+ int idx, cpl_tmp;
float f1,f2;
- float* cplscale;
+ const float* cplscale;
memset(decouple_tab, 0, sizeof(decouple_tab));
memset(decode_buffer, 0, sizeof(decode_buffer));
for (i=q->js_subband_start ; i<q->subbands ; i++) {
cpl_tmp = cplband[i];
idx -=decouple_tab[cpl_tmp];
- cplscale = (float*)cplscales[q->js_vlc_bits-2]; //choose decoupler table
+ cplscale = q->cplscales[q->js_vlc_bits-2]; //choose decoupler table
f1 = cplscale[decouple_tab[cpl_tmp]];
f2 = cplscale[idx-1];
- decouple_float (q, i, f1, f2, decode_buffer, mlt_buffer1, mlt_buffer2);
+ q->decouple (q, i, f1, f2, decode_buffer, mlt_buffer1, mlt_buffer2);
idx = (1 << q->js_vlc_bits) - 1;
}
}
*/
static inline void
-decode_bytes_and_gain(COOKContext *q, uint8_t *inbuffer,
+decode_bytes_and_gain(COOKContext *q, const uint8_t *inbuffer,
cook_gains *gains_ptr)
{
int offset;
saturate_output_float (COOKContext *q, int chan, int16_t *out)
{
int j;
- float_t *output = q->mono_mdct_output + q->samples_per_channel;
+ float *output = q->mono_mdct_output + q->samples_per_channel;
/* Clip and convert floats to 16 bits.
*/
for (j = 0; j < q->samples_per_channel; j++) {
out[chan + q->nb_channels * j] =
- av_clip(lrintf(output[j]), -32768, 32767);
+ av_clip_int16(lrintf(output[j]));
}
}
int16_t *out, int chan)
{
imlt_gain(q, decode_buffer, gains, previous_buffer);
- saturate_output_float (q, chan, out);
+ q->saturate_output (q, chan, out);
}
*/
-static int decode_subpacket(COOKContext *q, uint8_t *inbuffer,
+static int decode_subpacket(COOKContext *q, const uint8_t *inbuffer,
int sub_packet_size, int16_t *outbuffer) {
/* packet dump */
// for (i=0 ; i<sub_packet_size ; i++) {
-// av_log(NULL, AV_LOG_ERROR, "%02x", inbuffer[i]);
+// av_log(q->avctx, AV_LOG_ERROR, "%02x", inbuffer[i]);
// }
-// av_log(NULL, AV_LOG_ERROR, "\n");
+// av_log(q->avctx, AV_LOG_ERROR, "\n");
decode_bytes_and_gain(q, inbuffer, &q->gains1);
static int cook_decode_frame(AVCodecContext *avctx,
void *data, int *data_size,
- uint8_t *buf, int buf_size) {
+ AVPacket *avpkt) {
+ const uint8_t *buf = avpkt->data;
+ int buf_size = avpkt->size;
COOKContext *q = avctx->priv_data;
if (buf_size < avctx->block_align)
static void dump_cook_context(COOKContext *q)
{
//int i=0;
-#define PRINT(a,b) av_log(NULL,AV_LOG_ERROR," %s = %d\n", a, b);
- av_log(NULL,AV_LOG_ERROR,"COOKextradata\n");
- av_log(NULL,AV_LOG_ERROR,"cookversion=%x\n",q->cookversion);
+#define PRINT(a,b) av_log(q->avctx,AV_LOG_ERROR," %s = %d\n", a, b);
+ av_log(q->avctx,AV_LOG_ERROR,"COOKextradata\n");
+ av_log(q->avctx,AV_LOG_ERROR,"cookversion=%x\n",q->cookversion);
if (q->cookversion > STEREO) {
PRINT("js_subband_start",q->js_subband_start);
PRINT("js_vlc_bits",q->js_vlc_bits);
}
- av_log(NULL,AV_LOG_ERROR,"COOKContext\n");
+ av_log(q->avctx,AV_LOG_ERROR,"COOKContext\n");
PRINT("nb_channels",q->nb_channels);
PRINT("bit_rate",q->bit_rate);
PRINT("sample_rate",q->sample_rate);
}
#endif
+static av_cold int cook_count_channels(unsigned int mask){
+ int i;
+ int channels = 0;
+ for(i = 0;i<32;i++){
+ if(mask & (1<<i))
+ ++channels;
+ }
+ return channels;
+}
+
/**
* Cook initialization
*
* @param avctx pointer to the AVCodecContext
*/
-static int cook_decode_init(AVCodecContext *avctx)
+static av_cold int cook_decode_init(AVCodecContext *avctx)
{
COOKContext *q = avctx->priv_data;
- uint8_t *edata_ptr = avctx->extradata;
+ const uint8_t *edata_ptr = avctx->extradata;
+ q->avctx = avctx;
/* Take care of the codec specific extradata. */
if (avctx->extradata_size <= 0) {
q->bit_rate = avctx->bit_rate;
/* Initialize RNG. */
- av_init_random(1, &q->random_state);
+ av_lfg_init(&q->random_state, ff_random_get_seed());
/* Initialize extradata related variables. */
q->samples_per_channel = q->samples_per_frame / q->nb_channels;
q->total_subbands = q->subbands;
/* Initialize version-dependent variables */
- av_log(NULL,AV_LOG_DEBUG,"q->cookversion=%x\n",q->cookversion);
+ av_log(avctx,AV_LOG_DEBUG,"q->cookversion=%x\n",q->cookversion);
q->joint_stereo = 0;
switch (q->cookversion) {
case MONO:
q->numvector_size = (1 << q->log2_numvector_size);
/* Generate tables */
- init_rootpow2table(q);
- init_pow2table(q);
+ init_pow2table();
init_gain_table(q);
+ init_cplscales_table(q);
if (init_cook_vlc_tables(q) != 0)
return -1;
if ( init_cook_mlt(q) != 0 )
return -1;
+ /* Initialize COOK signal arithmetic handling */
+ if (1) {
+ q->scalar_dequant = scalar_dequant_float;
+ q->decouple = decouple_float;
+ q->imlt_window = imlt_window_float;
+ q->interpolate = interpolate_float;
+ q->saturate_output = saturate_output_float;
+ }
+
/* Try to catch some obviously faulty streams, othervise it might be exploitable */
if (q->total_subbands > 53) {
av_log(avctx,AV_LOG_ERROR,"total_subbands > 53, report sample!\n");
return -1;
}
+ avctx->sample_fmt = SAMPLE_FMT_S16;
+ avctx->channel_layout = (avctx->channels==2) ? CH_LAYOUT_STEREO : CH_LAYOUT_MONO;
+
#ifdef COOKDEBUG
dump_cook_context(q);
#endif
.init = cook_decode_init,
.close = cook_decode_close,
.decode = cook_decode_frame,
+ .long_name = NULL_IF_CONFIG_SMALL("COOK"),
};
projects / ffmpeg / blobdiff