← Back to branch summary

~xiph/celt/trunk

« back to all changes in this revision

Viewing changes to libcelt/celt.c

  • Committer: Jean-Marc Valin
  • Date: 2011-03-28 05:39:41 UTC
  • Revision ID: git-v1:9dec74d98d74e936569507a995e2401d324d1df5
Adds support for decoding stereo streams with a mono decoder

We don't allow *encoding* a stereo stream with a mono encoder
because that's just silly.

Show diffs side-by-side

added added

removed removed

Lines of Context:
libcelt/celt.c
1897
1897
   
1898
1898
   celt_sig _decode_mem[1]; /* Size = channels*(DECODE_BUFFER_SIZE+mode->overlap) */
1899
1899
   /* celt_word16 lpc[],  Size = channels*LPC_ORDER */
1900
 
   /* celt_word16 oldEBands[], Size = channels*mode->nbEBands */
1901
 
   /* celt_word16 oldLogE[], Size = channels*mode->nbEBands */
1902
 
   /* celt_word16 oldLogE2[], Size = channels*mode->nbEBands */
1903
 
   /* celt_word16 backgroundLogE[], Size = channels*mode->nbEBands */
 
1900
   /* celt_word16 oldEBands[], Size = 2*mode->nbEBands */
 
1901
   /* celt_word16 oldLogE[], Size = 2*mode->nbEBands */
 
1902
   /* celt_word16 oldLogE2[], Size = 2*mode->nbEBands */
 
1903
   /* celt_word16 backgroundLogE[], Size = 2*mode->nbEBands */
1904
1904
};
1905
1905
 
1906
1906
int celt_decoder_get_size(int channels)
1914
1914
   int size = sizeof(struct CELTDecoder)
1915
1915
            + (channels*(DECODE_BUFFER_SIZE+mode->overlap)-1)*sizeof(celt_sig)
1916
1916
            + channels*LPC_ORDER*sizeof(celt_word16)
1917
 
            + 4*channels*mode->nbEBands*sizeof(celt_word16);
 
1917
            + 4*2*mode->nbEBands*sizeof(celt_word16);
1918
1918
   return size;
1919
1919
}
1920
1920
 
2309
2309
      overlap_mem[c] = decode_mem[c]+DECODE_BUFFER_SIZE;
2310
2310
   } while (++c<CC);
2311
2311
   lpc = (celt_word16*)(st->_decode_mem+(DECODE_BUFFER_SIZE+st->overlap)*CC);
2312
 
   oldBandE = lpc+CC*LPC_ORDER;
2313
 
   oldLogE = oldBandE + CC*st->mode->nbEBands;
2314
 
   oldLogE2 = oldLogE + CC*st->mode->nbEBands;
2315
 
   backgroundLogE = oldLogE2  + CC*st->mode->nbEBands;
 
2312
   oldBandE = lpc+LPC_ORDER;
 
2313
   oldLogE = oldBandE + 2*st->mode->nbEBands;
 
2314
   oldLogE2 = oldLogE + 2*st->mode->nbEBands;
 
2315
   backgroundLogE = oldLogE2  + 2*st->mode->nbEBands;
2316
2316
 
2317
2317
   if (st->signalling && data!=NULL)
2318
2318
   {
2353
2353
   if (effEnd > st->mode->effEBands)
2354
2354
      effEnd = st->mode->effEBands;
2355
2355
 
2356
 
   ALLOC(freq, CC*N, celt_sig); /**< Interleaved signal MDCTs */
2357
 
   ALLOC(X, CC*N, celt_norm);   /**< Interleaved normalised MDCTs */
2358
 
   ALLOC(bandE, st->mode->nbEBands*CC, celt_ener);
 
2356
   ALLOC(freq, IMAX(CC,C)*N, celt_sig); /**< Interleaved signal MDCTs */
 
2357
   ALLOC(X, C*N, celt_norm);   /**< Interleaved normalised MDCTs */
 
2358
   ALLOC(bandE, st->mode->nbEBands*C, celt_ener);
2359
2359
   c=0; do
2360
2360
      for (i=0;i<M*st->mode->eBands[st->start];i++)
2361
2361
         X[c*N+i] = 0;
2362
 
   while (++c<CC);
 
2362
   while (++c<C);
2363
2363
   c=0; do   
2364
2364
      for (i=M*st->mode->eBands[effEnd];i<N;i++)
2365
2365
         X[c*N+i] = 0;
2366
 
   while (++c<CC);
 
2366
   while (++c<C);
2367
2367
 
2368
2368
   if (data == NULL || len<=1)
2369
2369
   {
2382
2382
      dec = &_dec;
2383
2383
   }
2384
2384
 
2385
 
   if (C>CC)
2386
 
   {
2387
 
      RESTORE_STACK;
2388
 
      return CELT_CORRUPTED_DATA;
2389
 
   } else if (C<CC)
 
2385
   if (C<CC)
2390
2386
   {
2391
2387
      for (i=0;i<st->mode->nbEBands;i++)
2392
2388
         oldBandE[i]=MAX16(oldBandE[i],oldBandE[st->mode->nbEBands+i]);
2522
2518
         fine_quant, fine_priority, len*8-ec_tell(dec), dec, C);
2523
2519
 
2524
2520
   if (anti_collapse_on)
2525
 
      anti_collapse(st->mode, X, collapse_masks, LM, C, CC, N,
 
2521
      anti_collapse(st->mode, X, collapse_masks, LM, C, C, N,
2526
2522
            st->start, st->end, oldBandE, oldLogE, oldLogE2, pulses, st->rng);
2527
2523
 
2528
2524
   log2Amp(st->mode, st->start, st->end, bandE, oldBandE, C);
2563
2559
      for (i=0;i<N;i++)
2564
2560
         freq[N+i] = freq[i];
2565
2561
   }
 
2562
   if (CC==1&&C==2)
 
2563
   {
 
2564
      for (i=0;i<N;i++)
 
2565
         freq[i] = HALF32(ADD32(freq[i],freq[N+i]));
 
2566
   }
2566
2567
 
2567
2568
   /* Compute inverse MDCTs */
2568
2569
   compute_inv_mdcts(st->mode, shortBlocks, freq, out_syn, overlap_mem, CC, LM);
2594
2595
   }
2595
2596
#endif /* ENABLE_POSTFILTER */
2596
2597
 
2597
 
   if (CC==2&&C==1) {
 
2598
   if (C==1) {
2598
2599
      for (i=0;i<st->mode->nbEBands;i++)
2599
2600
         oldBandE[st->mode->nbEBands+i]=oldBandE[i];
2600
2601
   }
2606
2607
         oldBandE[c*st->mode->nbEBands+i]=0;
2607
2608
      for (i=st->end;i<st->mode->nbEBands;i++)
2608
2609
         oldBandE[c*st->mode->nbEBands+i]=0;
2609
 
   } while (++c<CC);
 
2610
   } while (++c<2);
2610
2611
   if (!isTransient)
2611
2612
   {
2612
 
      for (i=0;i<CC*st->mode->nbEBands;i++)
 
2613
      for (i=0;i<2*st->mode->nbEBands;i++)
2613
2614
         oldLogE2[i] = oldLogE[i];
2614
 
      for (i=0;i<CC*st->mode->nbEBands;i++)
 
2615
      for (i=0;i<2*st->mode->nbEBands;i++)
2615
2616
         oldLogE[i] = oldBandE[i];
2616
 
      for (i=0;i<CC*st->mode->nbEBands;i++)
 
2617
      for (i=0;i<2*st->mode->nbEBands;i++)
2617
2618
         backgroundLogE[i] = MIN16(backgroundLogE[i] + M*QCONST16(0.001f,DB_SHIFT), oldBandE[i]);
2618
2619
   } else {
2619
 
      for (i=0;i<CC*st->mode->nbEBands;i++)
 
2620
      for (i=0;i<2*st->mode->nbEBands;i++)
2620
2621
         oldLogE[i] = MIN16(oldLogE[i], oldBandE[i]);
2621
2622
   }
2622
2623
   st->rng = dec->rng;