00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00033 #include "avcodec.h"
00034 #include "random.h"
00035 #include "dsputil.h"
00036
00037 #define ALT_BITSTREAM_READER_LE
00038 #include "bitstream.h"
00039
00040 #define NELLY_BANDS 23
00041 #define NELLY_BLOCK_LEN 64
00042 #define NELLY_HEADER_BITS 116
00043 #define NELLY_DETAIL_BITS 198
00044 #define NELLY_BUF_LEN 128
00045 #define NELLY_FILL_LEN 124
00046 #define NELLY_BIT_CAP 6
00047 #define NELLY_BASE_OFF 4228
00048 #define NELLY_BASE_SHIFT 19
00049 #define NELLY_SAMPLES (2 * NELLY_BUF_LEN)
00050
00051 static const float dequantization_table[127] = {
00052 0.0000000000,-0.8472560048, 0.7224709988, -1.5247479677, -0.4531480074, 0.3753609955, 1.4717899561,
00053 -1.9822579622, -1.1929379702, -0.5829370022, -0.0693780035, 0.3909569979,0.9069200158, 1.4862740040,
00054 2.2215409279, -2.3887870312, -1.8067539930, -1.4105420113, -1.0773609877, -0.7995010018,-0.5558109879,
00055 -0.3334020078, -0.1324490011, 0.0568020009, 0.2548770010, 0.4773550034, 0.7386850119, 1.0443060398,
00056 1.3954459429, 1.8098750114, 2.3918759823,-2.3893830776, -1.9884680510, -1.7514040470, -1.5643119812,
00057 -1.3922129869,-1.2164649963, -1.0469499826, -0.8905100226, -0.7645580173, -0.6454579830, -0.5259280205,
00058 -0.4059549868, -0.3029719889, -0.2096900046, -0.1239869967, -0.0479229987, 0.0257730000, 0.1001340002,
00059 0.1737180054, 0.2585540116, 0.3522900045, 0.4569880068, 0.5767750144, 0.7003160119, 0.8425520062,
00060 1.0093879700, 1.1821349859, 1.3534560204, 1.5320819616, 1.7332619429, 1.9722349644, 2.3978140354,
00061 -2.5756309032, -2.0573320389, -1.8984919786, -1.7727810144, -1.6662600040, -1.5742180347, -1.4993319511,
00062 -1.4316639900, -1.3652280569, -1.3000990152, -1.2280930281, -1.1588579416, -1.0921250582, -1.0135740042,
00063 -0.9202849865, -0.8287050128, -0.7374889851, -0.6447759867, -0.5590940118, -0.4857139885, -0.4110319912,
00064 -0.3459700048, -0.2851159871, -0.2341620028, -0.1870580018, -0.1442500055, -0.1107169986, -0.0739680007,
00065 -0.0365610011, -0.0073290002, 0.0203610007, 0.0479039997, 0.0751969963, 0.0980999991, 0.1220389977,
00066 0.1458999962, 0.1694349945, 0.1970459968, 0.2252430022, 0.2556869984, 0.2870100141, 0.3197099864,
00067 0.3525829911, 0.3889069855, 0.4334920049, 0.4769459963, 0.5204820037, 0.5644530058, 0.6122040153,
00068 0.6685929894, 0.7341650128, 0.8032159805, 0.8784040213, 0.9566209912, 1.0397069454, 1.1293770075,
00069 1.2211159468, 1.3080279827, 1.4024800062, 1.5056819916, 1.6227730513, 1.7724959850, 1.9430880547,
00070 2.2903931141
00071 };
00072
00073 static const uint8_t nelly_band_sizes_table[NELLY_BANDS] = {
00074 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 4, 4, 5, 6, 6, 7, 8, 9, 10, 12, 14, 15
00075 };
00076
00077 static const uint16_t nelly_init_table[64] = {
00078 3134, 5342, 6870, 7792, 8569, 9185, 9744, 10191, 10631, 11061, 11434, 11770,
00079 12116, 12513, 12925, 13300, 13674, 14027, 14352, 14716, 15117, 15477, 15824,
00080 16157, 16513, 16804, 17090, 17401, 17679, 17948, 18238, 18520, 18764, 19078,
00081 19381, 19640, 19921, 20205, 20500, 20813, 21162, 21465, 21794, 22137, 22453,
00082 22756, 23067, 23350, 23636, 23926, 24227, 24521, 24819, 25107, 25414, 25730,
00083 26120, 26497, 26895, 27344, 27877, 28463, 29426, 31355
00084 };
00085
00086 static const int16_t nelly_delta_table[32] = {
00087 -11725, -9420, -7910, -6801, -5948, -5233, -4599, -4039, -3507, -3030, -2596,
00088 -2170, -1774, -1383, -1016, -660, -329, -1, 337, 696, 1085, 1512, 1962, 2433,
00089 2968, 3569, 4314, 5279, 6622, 8154, 10076, 12975
00090 };
00091
00092 typedef struct NellyMoserDecodeContext {
00093 AVCodecContext* avctx;
00094 DECLARE_ALIGNED_16(float,float_buf[NELLY_SAMPLES]);
00095 float state[64];
00096 AVRandomState random_state;
00097 GetBitContext gb;
00098 int add_bias;
00099 int scale_bias;
00100 DSPContext dsp;
00101 MDCTContext imdct_ctx;
00102 DECLARE_ALIGNED_16(float,imdct_tmp[NELLY_BUF_LEN]);
00103 DECLARE_ALIGNED_16(float,imdct_out[NELLY_BUF_LEN * 2]);
00104 } NellyMoserDecodeContext;
00105
00106 static DECLARE_ALIGNED_16(float,sine_window[128]);
00107
00108 static inline int signed_shift(int i, int shift) {
00109 if (shift > 0)
00110 return i << shift;
00111 return i >> -shift;
00112 }
00113
00114 static void overlap_and_window(NellyMoserDecodeContext *s, float *state, float *audio)
00115 {
00116 int bot, mid_up, mid_down, top;
00117 float s_bot, s_top;
00118
00119 bot = 0;
00120 top = NELLY_BUF_LEN-1;
00121 mid_up = NELLY_BUF_LEN/2;
00122 mid_down = (NELLY_BUF_LEN/2)-1;
00123
00124 while (bot < NELLY_BUF_LEN/4) {
00125 s_bot = audio[bot];
00126 s_top = -audio[top];
00127 audio[bot] = (-audio[mid_up]*sine_window[bot]-state[bot ]*sine_window[top])/s->scale_bias + s->add_bias;
00128 audio[top] = (-state[bot ]*sine_window[bot]+audio[mid_up]*sine_window[top])/s->scale_bias + s->add_bias;
00129 state[bot] = audio[mid_down];
00130
00131 audio[mid_down] = (s_top *sine_window[mid_down]-state[mid_down]*sine_window[mid_up])/s->scale_bias + s->add_bias;
00132 audio[mid_up ] = (-state[mid_down]*sine_window[mid_down]-s_top *sine_window[mid_up])/s->scale_bias + s->add_bias;
00133 state[mid_down] = s_bot;
00134
00135 bot++;
00136 mid_up++;
00137 mid_down--;
00138 top--;
00139 }
00140 }
00141
00142 static int sum_bits(short *buf, short shift, short off)
00143 {
00144 int b, i = 0, ret = 0;
00145
00146 for (i = 0; i < NELLY_FILL_LEN; i++) {
00147 b = buf[i]-off;
00148 b = ((b>>(shift-1))+1)>>1;
00149 ret += av_clip(b, 0, NELLY_BIT_CAP);
00150 }
00151
00152 return ret;
00153 }
00154
00155 static int headroom(int *la)
00156 {
00157 int l;
00158 if (*la == 0) {
00159 return 31;
00160 }
00161 l = 30 - av_log2(FFABS(*la));
00162 *la <<= l;
00163 return l;
00164 }
00165
00166
00167 static void get_sample_bits(const float *buf, int *bits)
00168 {
00169 int i, j;
00170 short sbuf[128];
00171 int bitsum = 0, last_bitsum, small_bitsum, big_bitsum;
00172 short shift, shift_saved;
00173 int max, sum, last_off, tmp;
00174 int big_off, small_off;
00175 int off;
00176
00177 max = 0;
00178 for (i = 0; i < NELLY_FILL_LEN; i++) {
00179 max = FFMAX(max, buf[i]);
00180 }
00181 shift = -16;
00182 shift += headroom(&max);
00183
00184 sum = 0;
00185 for (i = 0; i < NELLY_FILL_LEN; i++) {
00186 sbuf[i] = signed_shift(buf[i], shift);
00187 sbuf[i] = (3*sbuf[i])>>2;
00188 sum += sbuf[i];
00189 }
00190
00191 shift += 11;
00192 shift_saved = shift;
00193 sum -= NELLY_DETAIL_BITS << shift;
00194 shift += headroom(&sum);
00195 small_off = (NELLY_BASE_OFF * (sum>>16)) >> 15;
00196 shift = shift_saved - (NELLY_BASE_SHIFT+shift-31);
00197
00198 small_off = signed_shift(small_off, shift);
00199
00200 bitsum = sum_bits(sbuf, shift_saved, small_off);
00201
00202 if (bitsum != NELLY_DETAIL_BITS) {
00203 shift = 0;
00204 off = bitsum - NELLY_DETAIL_BITS;
00205
00206 for(shift=0; FFABS(off) <= 16383; shift++)
00207 off *= 2;
00208
00209 off = (off * NELLY_BASE_OFF) >> 15;
00210 shift = shift_saved-(NELLY_BASE_SHIFT+shift-15);
00211
00212 off = signed_shift(off, shift);
00213
00214 for (j = 1; j < 20; j++) {
00215 last_off = small_off;
00216 small_off += off;
00217 last_bitsum = bitsum;
00218
00219 bitsum = sum_bits(sbuf, shift_saved, small_off);
00220
00221 if ((bitsum-NELLY_DETAIL_BITS) * (last_bitsum-NELLY_DETAIL_BITS) <= 0)
00222 break;
00223 }
00224
00225 if (bitsum > NELLY_DETAIL_BITS) {
00226 big_off = small_off;
00227 small_off = last_off;
00228 big_bitsum=bitsum;
00229 small_bitsum=last_bitsum;
00230 } else {
00231 big_off = last_off;
00232 big_bitsum=last_bitsum;
00233 small_bitsum=bitsum;
00234 }
00235
00236 while (bitsum != NELLY_DETAIL_BITS && j <= 19) {
00237 off = (big_off+small_off)>>1;
00238 bitsum = sum_bits(sbuf, shift_saved, off);
00239 if (bitsum > NELLY_DETAIL_BITS) {
00240 big_off=off;
00241 big_bitsum=bitsum;
00242 } else {
00243 small_off = off;
00244 small_bitsum=bitsum;
00245 }
00246 j++;
00247 }
00248
00249 if (abs(big_bitsum-NELLY_DETAIL_BITS) >=
00250 abs(small_bitsum-NELLY_DETAIL_BITS)) {
00251 bitsum = small_bitsum;
00252 } else {
00253 small_off = big_off;
00254 bitsum = big_bitsum;
00255 }
00256 }
00257
00258 for (i = 0; i < NELLY_FILL_LEN; i++) {
00259 tmp = sbuf[i]-small_off;
00260 tmp = ((tmp>>(shift_saved-1))+1)>>1;
00261 bits[i] = av_clip(tmp, 0, NELLY_BIT_CAP);
00262 }
00263
00264 if (bitsum > NELLY_DETAIL_BITS) {
00265 tmp = i = 0;
00266 while (tmp < NELLY_DETAIL_BITS) {
00267 tmp += bits[i];
00268 i++;
00269 }
00270
00271 bits[i-1] -= tmp - NELLY_DETAIL_BITS;
00272 for(; i < NELLY_FILL_LEN; i++)
00273 bits[i] = 0;
00274 }
00275 }
00276
00277 void nelly_decode_block(NellyMoserDecodeContext *s, const unsigned char block[NELLY_BLOCK_LEN], float audio[NELLY_SAMPLES])
00278 {
00279 int i,j;
00280 float buf[NELLY_FILL_LEN], pows[NELLY_FILL_LEN];
00281 float *aptr, *bptr, *pptr, val, pval;
00282 int bits[NELLY_BUF_LEN];
00283 unsigned char v;
00284
00285 init_get_bits(&s->gb, block, NELLY_BLOCK_LEN * 8);
00286
00287 bptr = buf;
00288 pptr = pows;
00289 val = nelly_init_table[get_bits(&s->gb, 6)];
00290 for (i=0 ; i<NELLY_BANDS ; i++) {
00291 if (i > 0)
00292 val += nelly_delta_table[get_bits(&s->gb, 5)];
00293 pval = pow(2, val/2048);
00294 for (j = 0; j < nelly_band_sizes_table[i]; j++) {
00295 *bptr++ = val;
00296 *pptr++ = pval;
00297 }
00298
00299 }
00300
00301 get_sample_bits(buf, bits);
00302
00303 for (i = 0; i < 2; i++) {
00304 aptr = audio + i * NELLY_BUF_LEN;
00305
00306 init_get_bits(&s->gb, block, NELLY_BLOCK_LEN * 8);
00307 skip_bits(&s->gb, NELLY_HEADER_BITS + i*NELLY_DETAIL_BITS);
00308
00309 for (j = 0; j < NELLY_FILL_LEN; j++) {
00310 if (bits[j] <= 0) {
00311 aptr[j] = M_SQRT1_2*pows[j];
00312 if (av_random(&s->random_state) & 1)
00313 aptr[j] *= -1.0;
00314 } else {
00315 v = get_bits(&s->gb, bits[j]);
00316 aptr[j] = dequantization_table[(1<<bits[j])-1+v]*pows[j];
00317 }
00318 }
00319 memset(&aptr[NELLY_FILL_LEN], 0,
00320 (NELLY_BUF_LEN - NELLY_FILL_LEN) * sizeof(float));
00321
00322 s->imdct_ctx.fft.imdct_calc(&s->imdct_ctx, s->imdct_out,
00323 aptr, s->imdct_tmp);
00324
00325
00326 memcpy(&aptr[0],&s->imdct_out[NELLY_BUF_LEN+NELLY_BUF_LEN/2], (NELLY_BUF_LEN/2)*sizeof(float));
00327 memcpy(&aptr[NELLY_BUF_LEN / 2],&s->imdct_out[0],(NELLY_BUF_LEN/2)*sizeof(float));
00328 overlap_and_window(s, s->state, aptr);
00329 }
00330 }
00331
00332 static int decode_init(AVCodecContext * avctx) {
00333 NellyMoserDecodeContext *s = avctx->priv_data;
00334 int i;
00335
00336 s->avctx = avctx;
00337 av_init_random(0, &s->random_state);
00338 ff_mdct_init(&s->imdct_ctx, 8, 1);
00339
00340 dsputil_init(&s->dsp, avctx);
00341
00342 if(s->dsp.float_to_int16 == ff_float_to_int16_c) {
00343 s->add_bias = 385;
00344 s->scale_bias = 8*32768;
00345 } else {
00346 s->add_bias = 0;
00347 s->scale_bias = 1*8;
00348 }
00349
00350
00351 if (!sine_window[0])
00352 for (i=0 ; i<128; i++) {
00353 sine_window[i] = sin((i + 0.5) / 256.0 * M_PI);
00354 }
00355
00356 return 0;
00357 }
00358
00359 static int decode_tag(AVCodecContext * avctx,
00360 void *data, int *data_size,
00361 const uint8_t * buf, int buf_size) {
00362 NellyMoserDecodeContext *s = avctx->priv_data;
00363 int blocks, i;
00364 int16_t* samples;
00365 *data_size = 0;
00366 samples = (int16_t*)data;
00367
00368 if (buf_size < avctx->block_align)
00369 return buf_size;
00370
00371 switch (buf_size) {
00372 case 64:
00373 blocks = 1; break;
00374 case 128:
00375 blocks = 2; break;
00376 case 256:
00377 blocks = 4; break;
00378 case 512:
00379 blocks = 8; break;
00380 default:
00381 av_log(avctx, AV_LOG_ERROR, "Tag size %d unknown, report sample!\n", buf_size);
00382 return buf_size;
00383 }
00384
00385 for (i=0 ; i<blocks ; i++) {
00386 nelly_decode_block(s, &buf[i*NELLY_BLOCK_LEN], s->float_buf);
00387 s->dsp.float_to_int16(&samples[i*NELLY_SAMPLES], s->float_buf, NELLY_SAMPLES);
00388 *data_size += NELLY_SAMPLES*sizeof(int16_t);
00389 }
00390
00391 return buf_size;
00392 }
00393
00394 static int decode_end(AVCodecContext * avctx) {
00395 NellyMoserDecodeContext *s = avctx->priv_data;
00396
00397 ff_mdct_end(&s->imdct_ctx);
00398 return 0;
00399 }
00400
00401 AVCodec nellymoser_decoder = {
00402 "nellymoser",
00403 CODEC_TYPE_AUDIO,
00404 CODEC_ID_NELLYMOSER,
00405 sizeof(NellyMoserDecodeContext),
00406 decode_init,
00407 NULL,
00408 decode_end,
00409 decode_tag,
00410 };
00411