#include <stddef.h>
#include <stdio.h>
+#include "libavutil/random.h"
#include "avcodec.h"
#include "bitstream.h"
#include "dsputil.h"
#include "bytestream.h"
-#include "random.h"
#include "cookdata.h"
/* 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 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));
}
}
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_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)) {
return 0;
}
+static const float *maybe_reformat_buffer32 (COOKContext *q, const float *ptr, int n)
+{
+ if (1)
+ return ptr;
+}
+
+static 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
* Buffer alignment needs to be checked. */
off = (int)((long)inbuffer & 3);
- buf = (uint32_t*) (inbuffer - off);
+ 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++)
* 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)
* @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;
f1 = dither_tab[index];
if (av_random(&q->random_state) < 0x80000000) f1 = -f1;
}
- mlt_p[i] = f1 * q->rootpow2tab[quant_index+63];
+ mlt_p[i] = f1 * rootpow2tab[quant_index+63];
}
}
/**
memset(subband_coef_sign, 0, sizeof(subband_coef_sign));
}
q->scalar_dequant(q, index, quant_index_table[band],
- subband_coef_index, subband_coef_sign,
- &mlt_buffer[band * SUBBAND_SIZE]);
+ 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
for (i = 0; i < 8; i++) {
if (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]);
+ 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];
q->decouple (q, i, f1, f2, decode_buffer, mlt_buffer1, mlt_buffer2);
*/
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]));
}
}
*/
-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++) {
static int cook_decode_frame(AVCodecContext *avctx,
void *data, int *data_size,
- uint8_t *buf, int buf_size) {
+ const uint8_t *buf, int buf_size) {
COOKContext *q = avctx->priv_data;
if (buf_size < avctx->block_align)
static int cook_decode_init(AVCodecContext *avctx)
{
COOKContext *q = avctx->priv_data;
- uint8_t *edata_ptr = avctx->extradata;
+ const uint8_t *edata_ptr = avctx->extradata;
/* Take care of the codec specific extradata. */
if (avctx->extradata_size <= 0) {
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;
/* Initialize COOK signal arithmetic handling */
if (1) {
- q->scalar_dequant = scalar_dequant;
+ q->scalar_dequant = scalar_dequant_float;
q->decouple = decouple_float;
q->imlt_window = imlt_window_float;
- q->interpolate = interpolate;
+ q->interpolate = interpolate_float;
q->saturate_output = saturate_output_float;
}
return -1;
}
+ avctx->sample_fmt = SAMPLE_FMT_S16;
+
#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