• Main Page
  • Related Pages
  • Modules
  • Data Structures
  • Files
  • Examples
  • File List
  • Globals

libavcodec/wmaprodec.c

Go to the documentation of this file.
00001 /*
00002  * Wmapro compatible decoder
00003  * Copyright (c) 2007 Baptiste Coudurier, Benjamin Larsson, Ulion
00004  * Copyright (c) 2008 - 2011 Sascha Sommer, Benjamin Larsson
00005  *
00006  * This file is part of Libav.
00007  *
00008  * Libav is free software; you can redistribute it and/or
00009  * modify it under the terms of the GNU Lesser General Public
00010  * License as published by the Free Software Foundation; either
00011  * version 2.1 of the License, or (at your option) any later version.
00012  *
00013  * Libav is distributed in the hope that it will be useful,
00014  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00015  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00016  * Lesser General Public License for more details.
00017  *
00018  * You should have received a copy of the GNU Lesser General Public
00019  * License along with Libav; if not, write to the Free Software
00020  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
00021  */
00022 
00089 #include "libavutil/intfloat.h"
00090 #include "libavutil/intreadwrite.h"
00091 #include "avcodec.h"
00092 #include "internal.h"
00093 #include "get_bits.h"
00094 #include "put_bits.h"
00095 #include "wmaprodata.h"
00096 #include "dsputil.h"
00097 #include "fmtconvert.h"
00098 #include "sinewin.h"
00099 #include "wma.h"
00100 
00102 #define WMAPRO_MAX_CHANNELS    8                             ///< max number of handled channels
00103 #define MAX_SUBFRAMES  32                                    ///< max number of subframes per channel
00104 #define MAX_BANDS      29                                    ///< max number of scale factor bands
00105 #define MAX_FRAMESIZE  32768                                 ///< maximum compressed frame size
00106 
00107 #define WMAPRO_BLOCK_MIN_BITS  6                                           ///< log2 of min block size
00108 #define WMAPRO_BLOCK_MAX_BITS 12                                           ///< log2 of max block size
00109 #define WMAPRO_BLOCK_MAX_SIZE (1 << WMAPRO_BLOCK_MAX_BITS)                 ///< maximum block size
00110 #define WMAPRO_BLOCK_SIZES    (WMAPRO_BLOCK_MAX_BITS - WMAPRO_BLOCK_MIN_BITS + 1) ///< possible block sizes
00111 
00112 
00113 #define VLCBITS            9
00114 #define SCALEVLCBITS       8
00115 #define VEC4MAXDEPTH    ((HUFF_VEC4_MAXBITS+VLCBITS-1)/VLCBITS)
00116 #define VEC2MAXDEPTH    ((HUFF_VEC2_MAXBITS+VLCBITS-1)/VLCBITS)
00117 #define VEC1MAXDEPTH    ((HUFF_VEC1_MAXBITS+VLCBITS-1)/VLCBITS)
00118 #define SCALEMAXDEPTH   ((HUFF_SCALE_MAXBITS+SCALEVLCBITS-1)/SCALEVLCBITS)
00119 #define SCALERLMAXDEPTH ((HUFF_SCALE_RL_MAXBITS+VLCBITS-1)/VLCBITS)
00120 
00121 static VLC              sf_vlc;           
00122 static VLC              sf_rl_vlc;        
00123 static VLC              vec4_vlc;         
00124 static VLC              vec2_vlc;         
00125 static VLC              vec1_vlc;         
00126 static VLC              coef_vlc[2];      
00127 static float            sin64[33];        
00128 
00132 typedef struct {
00133     int16_t  prev_block_len;                          
00134     uint8_t  transmit_coefs;
00135     uint8_t  num_subframes;
00136     uint16_t subframe_len[MAX_SUBFRAMES];             
00137     uint16_t subframe_offset[MAX_SUBFRAMES];          
00138     uint8_t  cur_subframe;                            
00139     uint16_t decoded_samples;                         
00140     uint8_t  grouped;                                 
00141     int      quant_step;                              
00142     int8_t   reuse_sf;                                
00143     int8_t   scale_factor_step;                       
00144     int      max_scale_factor;                        
00145     int      saved_scale_factors[2][MAX_BANDS];       
00146     int8_t   scale_factor_idx;                        
00147     int*     scale_factors;                           
00148     uint8_t  table_idx;                               
00149     float*   coeffs;                                  
00150     uint16_t num_vec_coeffs;                          
00151     DECLARE_ALIGNED(32, float, out)[WMAPRO_BLOCK_MAX_SIZE + WMAPRO_BLOCK_MAX_SIZE / 2]; 
00152 } WMAProChannelCtx;
00153 
00157 typedef struct {
00158     uint8_t num_channels;                                     
00159     int8_t  transform;                                        
00160     int8_t  transform_band[MAX_BANDS];                        
00161     float   decorrelation_matrix[WMAPRO_MAX_CHANNELS*WMAPRO_MAX_CHANNELS];
00162     float*  channel_data[WMAPRO_MAX_CHANNELS];                
00163 } WMAProChannelGrp;
00164 
00168 typedef struct WMAProDecodeCtx {
00169     /* generic decoder variables */
00170     AVCodecContext*  avctx;                         
00171     AVFrame          frame;                         
00172     DSPContext       dsp;                           
00173     FmtConvertContext fmt_conv;
00174     uint8_t          frame_data[MAX_FRAMESIZE +
00175                       FF_INPUT_BUFFER_PADDING_SIZE];
00176     PutBitContext    pb;                            
00177     FFTContext       mdct_ctx[WMAPRO_BLOCK_SIZES];  
00178     DECLARE_ALIGNED(32, float, tmp)[WMAPRO_BLOCK_MAX_SIZE]; 
00179     float*           windows[WMAPRO_BLOCK_SIZES];   
00180 
00181     /* frame size dependent frame information (set during initialization) */
00182     uint32_t         decode_flags;                  
00183     uint8_t          len_prefix;                    
00184     uint8_t          dynamic_range_compression;     
00185     uint8_t          bits_per_sample;               
00186     uint16_t         samples_per_frame;             
00187     uint16_t         log2_frame_size;
00188     int8_t           num_channels;                  
00189     int8_t           lfe_channel;                   
00190     uint8_t          max_num_subframes;
00191     uint8_t          subframe_len_bits;             
00192     uint8_t          max_subframe_len_bit;          
00193     uint16_t         min_samples_per_subframe;
00194     int8_t           num_sfb[WMAPRO_BLOCK_SIZES];   
00195     int16_t          sfb_offsets[WMAPRO_BLOCK_SIZES][MAX_BANDS];                    
00196     int8_t           sf_offsets[WMAPRO_BLOCK_SIZES][WMAPRO_BLOCK_SIZES][MAX_BANDS]; 
00197     int16_t          subwoofer_cutoffs[WMAPRO_BLOCK_SIZES]; 
00198 
00199     /* packet decode state */
00200     GetBitContext    pgb;                           
00201     int              next_packet_start;             
00202     uint8_t          packet_offset;                 
00203     uint8_t          packet_sequence_number;        
00204     int              num_saved_bits;                
00205     int              frame_offset;                  
00206     int              subframe_offset;               
00207     uint8_t          packet_loss;                   
00208     uint8_t          packet_done;                   
00209 
00210     /* frame decode state */
00211     uint32_t         frame_num;                     
00212     GetBitContext    gb;                            
00213     int              buf_bit_size;                  
00214     uint8_t          drc_gain;                      
00215     int8_t           skip_frame;                    
00216     int8_t           parsed_all_subframes;          
00217 
00218     /* subframe/block decode state */
00219     int16_t          subframe_len;                  
00220     int8_t           channels_for_cur_subframe;     
00221     int8_t           channel_indexes_for_cur_subframe[WMAPRO_MAX_CHANNELS];
00222     int8_t           num_bands;                     
00223     int8_t           transmit_num_vec_coeffs;       
00224     int16_t*         cur_sfb_offsets;               
00225     uint8_t          table_idx;                     
00226     int8_t           esc_len;                       
00227 
00228     uint8_t          num_chgroups;                  
00229     WMAProChannelGrp chgroup[WMAPRO_MAX_CHANNELS];  
00230 
00231     WMAProChannelCtx channel[WMAPRO_MAX_CHANNELS];  
00232 } WMAProDecodeCtx;
00233 
00234 
00239 static void av_cold dump_context(WMAProDecodeCtx *s)
00240 {
00241 #define PRINT(a, b)     av_log(s->avctx, AV_LOG_DEBUG, " %s = %d\n", a, b);
00242 #define PRINT_HEX(a, b) av_log(s->avctx, AV_LOG_DEBUG, " %s = %x\n", a, b);
00243 
00244     PRINT("ed sample bit depth", s->bits_per_sample);
00245     PRINT_HEX("ed decode flags", s->decode_flags);
00246     PRINT("samples per frame",   s->samples_per_frame);
00247     PRINT("log2 frame size",     s->log2_frame_size);
00248     PRINT("max num subframes",   s->max_num_subframes);
00249     PRINT("len prefix",          s->len_prefix);
00250     PRINT("num channels",        s->num_channels);
00251 }
00252 
00258 static av_cold int decode_end(AVCodecContext *avctx)
00259 {
00260     WMAProDecodeCtx *s = avctx->priv_data;
00261     int i;
00262 
00263     for (i = 0; i < WMAPRO_BLOCK_SIZES; i++)
00264         ff_mdct_end(&s->mdct_ctx[i]);
00265 
00266     return 0;
00267 }
00268 
00274 static av_cold int decode_init(AVCodecContext *avctx)
00275 {
00276     WMAProDecodeCtx *s = avctx->priv_data;
00277     uint8_t *edata_ptr = avctx->extradata;
00278     unsigned int channel_mask;
00279     int i;
00280     int log2_max_num_subframes;
00281     int num_possible_block_sizes;
00282 
00283     if (!avctx->block_align) {
00284         av_log(avctx, AV_LOG_ERROR, "block_align is not set\n");
00285         return AVERROR(EINVAL);
00286     }
00287 
00288     s->avctx = avctx;
00289     dsputil_init(&s->dsp, avctx);
00290     ff_fmt_convert_init(&s->fmt_conv, avctx);
00291     init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE);
00292 
00293     avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
00294 
00295     if (avctx->extradata_size >= 18) {
00296         s->decode_flags    = AV_RL16(edata_ptr+14);
00297         channel_mask       = AV_RL32(edata_ptr+2);
00298         s->bits_per_sample = AV_RL16(edata_ptr);
00300         for (i = 0; i < avctx->extradata_size; i++)
00301             av_dlog(avctx, "[%x] ", avctx->extradata[i]);
00302         av_dlog(avctx, "\n");
00303 
00304     } else {
00305         av_log_ask_for_sample(avctx, "Unknown extradata size\n");
00306         return AVERROR_INVALIDDATA;
00307     }
00308 
00310     s->log2_frame_size = av_log2(avctx->block_align) + 4;
00311 
00313     s->skip_frame  = 1; /* skip first frame */
00314     s->packet_loss = 1;
00315     s->len_prefix  = (s->decode_flags & 0x40);
00316 
00318     s->samples_per_frame = 1 << ff_wma_get_frame_len_bits(avctx->sample_rate,
00319                                                           3, s->decode_flags);
00320 
00322     log2_max_num_subframes       = ((s->decode_flags & 0x38) >> 3);
00323     s->max_num_subframes         = 1 << log2_max_num_subframes;
00324     if (s->max_num_subframes == 16 || s->max_num_subframes == 4)
00325         s->max_subframe_len_bit = 1;
00326     s->subframe_len_bits = av_log2(log2_max_num_subframes) + 1;
00327 
00328     num_possible_block_sizes     = log2_max_num_subframes + 1;
00329     s->min_samples_per_subframe  = s->samples_per_frame / s->max_num_subframes;
00330     s->dynamic_range_compression = (s->decode_flags & 0x80);
00331 
00332     if (s->max_num_subframes > MAX_SUBFRAMES) {
00333         av_log(avctx, AV_LOG_ERROR, "invalid number of subframes %i\n",
00334                s->max_num_subframes);
00335         return AVERROR_INVALIDDATA;
00336     }
00337 
00338     if (s->avctx->sample_rate <= 0) {
00339         av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
00340         return AVERROR_INVALIDDATA;
00341     }
00342 
00343     s->num_channels = avctx->channels;
00344 
00345     if (s->num_channels < 0) {
00346         av_log(avctx, AV_LOG_ERROR, "invalid number of channels %d\n", s->num_channels);
00347         return AVERROR_INVALIDDATA;
00348     } else if (s->num_channels > WMAPRO_MAX_CHANNELS) {
00349         av_log_ask_for_sample(avctx, "unsupported number of channels\n");
00350         return AVERROR_PATCHWELCOME;
00351     }
00352 
00354     for (i = 0; i < s->num_channels; i++)
00355         s->channel[i].prev_block_len = s->samples_per_frame;
00356 
00358     s->lfe_channel = -1;
00359 
00360     if (channel_mask & 8) {
00361         unsigned int mask;
00362         for (mask = 1; mask < 16; mask <<= 1) {
00363             if (channel_mask & mask)
00364                 ++s->lfe_channel;
00365         }
00366     }
00367 
00368     INIT_VLC_STATIC(&sf_vlc, SCALEVLCBITS, HUFF_SCALE_SIZE,
00369                     scale_huffbits, 1, 1,
00370                     scale_huffcodes, 2, 2, 616);
00371 
00372     INIT_VLC_STATIC(&sf_rl_vlc, VLCBITS, HUFF_SCALE_RL_SIZE,
00373                     scale_rl_huffbits, 1, 1,
00374                     scale_rl_huffcodes, 4, 4, 1406);
00375 
00376     INIT_VLC_STATIC(&coef_vlc[0], VLCBITS, HUFF_COEF0_SIZE,
00377                     coef0_huffbits, 1, 1,
00378                     coef0_huffcodes, 4, 4, 2108);
00379 
00380     INIT_VLC_STATIC(&coef_vlc[1], VLCBITS, HUFF_COEF1_SIZE,
00381                     coef1_huffbits, 1, 1,
00382                     coef1_huffcodes, 4, 4, 3912);
00383 
00384     INIT_VLC_STATIC(&vec4_vlc, VLCBITS, HUFF_VEC4_SIZE,
00385                     vec4_huffbits, 1, 1,
00386                     vec4_huffcodes, 2, 2, 604);
00387 
00388     INIT_VLC_STATIC(&vec2_vlc, VLCBITS, HUFF_VEC2_SIZE,
00389                     vec2_huffbits, 1, 1,
00390                     vec2_huffcodes, 2, 2, 562);
00391 
00392     INIT_VLC_STATIC(&vec1_vlc, VLCBITS, HUFF_VEC1_SIZE,
00393                     vec1_huffbits, 1, 1,
00394                     vec1_huffcodes, 2, 2, 562);
00395 
00398     for (i = 0; i < num_possible_block_sizes; i++) {
00399         int subframe_len = s->samples_per_frame >> i;
00400         int x;
00401         int band = 1;
00402 
00403         s->sfb_offsets[i][0] = 0;
00404 
00405         for (x = 0; x < MAX_BANDS-1 && s->sfb_offsets[i][band - 1] < subframe_len; x++) {
00406             int offset = (subframe_len * 2 * critical_freq[x])
00407                           / s->avctx->sample_rate + 2;
00408             offset &= ~3;
00409             if (offset > s->sfb_offsets[i][band - 1])
00410                 s->sfb_offsets[i][band++] = offset;
00411         }
00412         s->sfb_offsets[i][band - 1] = subframe_len;
00413         s->num_sfb[i]               = band - 1;
00414     }
00415 
00416 
00422     for (i = 0; i < num_possible_block_sizes; i++) {
00423         int b;
00424         for (b = 0; b < s->num_sfb[i]; b++) {
00425             int x;
00426             int offset = ((s->sfb_offsets[i][b]
00427                            + s->sfb_offsets[i][b + 1] - 1) << i) >> 1;
00428             for (x = 0; x < num_possible_block_sizes; x++) {
00429                 int v = 0;
00430                 while (s->sfb_offsets[x][v + 1] << x < offset)
00431                     ++v;
00432                 s->sf_offsets[i][x][b] = v;
00433             }
00434         }
00435     }
00436 
00438     for (i = 0; i < WMAPRO_BLOCK_SIZES; i++)
00439         ff_mdct_init(&s->mdct_ctx[i], WMAPRO_BLOCK_MIN_BITS+1+i, 1,
00440                      1.0 / (1 << (WMAPRO_BLOCK_MIN_BITS + i - 1))
00441                      / (1 << (s->bits_per_sample - 1)));
00442 
00444     for (i = 0; i < WMAPRO_BLOCK_SIZES; i++) {
00445         const int win_idx = WMAPRO_BLOCK_MAX_BITS - i;
00446         ff_init_ff_sine_windows(win_idx);
00447         s->windows[WMAPRO_BLOCK_SIZES - i - 1] = ff_sine_windows[win_idx];
00448     }
00449 
00451     for (i = 0; i < num_possible_block_sizes; i++) {
00452         int block_size = s->samples_per_frame >> i;
00453         int cutoff = (440*block_size + 3 * (s->avctx->sample_rate >> 1) - 1)
00454                      / s->avctx->sample_rate;
00455         s->subwoofer_cutoffs[i] = av_clip(cutoff, 4, block_size);
00456     }
00457 
00459     for (i = 0; i < 33; i++)
00460         sin64[i] = sin(i*M_PI / 64.0);
00461 
00462     if (avctx->debug & FF_DEBUG_BITSTREAM)
00463         dump_context(s);
00464 
00465     avctx->channel_layout = channel_mask;
00466 
00467     avcodec_get_frame_defaults(&s->frame);
00468     avctx->coded_frame = &s->frame;
00469 
00470     return 0;
00471 }
00472 
00479 static int decode_subframe_length(WMAProDecodeCtx *s, int offset)
00480 {
00481     int frame_len_shift = 0;
00482     int subframe_len;
00483 
00485     if (offset == s->samples_per_frame - s->min_samples_per_subframe)
00486         return s->min_samples_per_subframe;
00487 
00489     if (s->max_subframe_len_bit) {
00490         if (get_bits1(&s->gb))
00491             frame_len_shift = 1 + get_bits(&s->gb, s->subframe_len_bits-1);
00492     } else
00493         frame_len_shift = get_bits(&s->gb, s->subframe_len_bits);
00494 
00495     subframe_len = s->samples_per_frame >> frame_len_shift;
00496 
00498     if (subframe_len < s->min_samples_per_subframe ||
00499         subframe_len > s->samples_per_frame) {
00500         av_log(s->avctx, AV_LOG_ERROR, "broken frame: subframe_len %i\n",
00501                subframe_len);
00502         return AVERROR_INVALIDDATA;
00503     }
00504     return subframe_len;
00505 }
00506 
00527 static int decode_tilehdr(WMAProDecodeCtx *s)
00528 {
00529     uint16_t num_samples[WMAPRO_MAX_CHANNELS];        
00530     uint8_t  contains_subframe[WMAPRO_MAX_CHANNELS];  
00531     int channels_for_cur_subframe = s->num_channels;  
00532     int fixed_channel_layout = 0;                     
00533     int min_channel_len = 0;                          
00534     int c;
00535 
00536     /* Should never consume more than 3073 bits (256 iterations for the
00537      * while loop when always the minimum amount of 128 samples is substracted
00538      * from missing samples in the 8 channel case).
00539      * 1 + BLOCK_MAX_SIZE * MAX_CHANNELS / BLOCK_MIN_SIZE * (MAX_CHANNELS  + 4)
00540      */
00541 
00543     for (c = 0; c < s->num_channels; c++)
00544         s->channel[c].num_subframes = 0;
00545 
00546     memset(num_samples, 0, sizeof(num_samples));
00547 
00548     if (s->max_num_subframes == 1 || get_bits1(&s->gb))
00549         fixed_channel_layout = 1;
00550 
00552     do {
00553         int subframe_len;
00554 
00556         for (c = 0; c < s->num_channels; c++) {
00557             if (num_samples[c] == min_channel_len) {
00558                 if (fixed_channel_layout || channels_for_cur_subframe == 1 ||
00559                    (min_channel_len == s->samples_per_frame - s->min_samples_per_subframe))
00560                     contains_subframe[c] = 1;
00561                 else
00562                     contains_subframe[c] = get_bits1(&s->gb);
00563             } else
00564                 contains_subframe[c] = 0;
00565         }
00566 
00568         if ((subframe_len = decode_subframe_length(s, min_channel_len)) <= 0)
00569             return AVERROR_INVALIDDATA;
00570 
00572         min_channel_len += subframe_len;
00573         for (c = 0; c < s->num_channels; c++) {
00574             WMAProChannelCtx* chan = &s->channel[c];
00575 
00576             if (contains_subframe[c]) {
00577                 if (chan->num_subframes >= MAX_SUBFRAMES) {
00578                     av_log(s->avctx, AV_LOG_ERROR,
00579                            "broken frame: num subframes > 31\n");
00580                     return AVERROR_INVALIDDATA;
00581                 }
00582                 chan->subframe_len[chan->num_subframes] = subframe_len;
00583                 num_samples[c] += subframe_len;
00584                 ++chan->num_subframes;
00585                 if (num_samples[c] > s->samples_per_frame) {
00586                     av_log(s->avctx, AV_LOG_ERROR, "broken frame: "
00587                            "channel len > samples_per_frame\n");
00588                     return AVERROR_INVALIDDATA;
00589                 }
00590             } else if (num_samples[c] <= min_channel_len) {
00591                 if (num_samples[c] < min_channel_len) {
00592                     channels_for_cur_subframe = 0;
00593                     min_channel_len = num_samples[c];
00594                 }
00595                 ++channels_for_cur_subframe;
00596             }
00597         }
00598     } while (min_channel_len < s->samples_per_frame);
00599 
00600     for (c = 0; c < s->num_channels; c++) {
00601         int i;
00602         int offset = 0;
00603         for (i = 0; i < s->channel[c].num_subframes; i++) {
00604             av_dlog(s->avctx, "frame[%i] channel[%i] subframe[%i]"
00605                     " len %i\n", s->frame_num, c, i,
00606                     s->channel[c].subframe_len[i]);
00607             s->channel[c].subframe_offset[i] = offset;
00608             offset += s->channel[c].subframe_len[i];
00609         }
00610     }
00611 
00612     return 0;
00613 }
00614 
00620 static void decode_decorrelation_matrix(WMAProDecodeCtx *s,
00621                                         WMAProChannelGrp *chgroup)
00622 {
00623     int i;
00624     int offset = 0;
00625     int8_t rotation_offset[WMAPRO_MAX_CHANNELS * WMAPRO_MAX_CHANNELS];
00626     memset(chgroup->decorrelation_matrix, 0, s->num_channels *
00627            s->num_channels * sizeof(*chgroup->decorrelation_matrix));
00628 
00629     for (i = 0; i < chgroup->num_channels * (chgroup->num_channels - 1) >> 1; i++)
00630         rotation_offset[i] = get_bits(&s->gb, 6);
00631 
00632     for (i = 0; i < chgroup->num_channels; i++)
00633         chgroup->decorrelation_matrix[chgroup->num_channels * i + i] =
00634             get_bits1(&s->gb) ? 1.0 : -1.0;
00635 
00636     for (i = 1; i < chgroup->num_channels; i++) {
00637         int x;
00638         for (x = 0; x < i; x++) {
00639             int y;
00640             for (y = 0; y < i + 1; y++) {
00641                 float v1 = chgroup->decorrelation_matrix[x * chgroup->num_channels + y];
00642                 float v2 = chgroup->decorrelation_matrix[i * chgroup->num_channels + y];
00643                 int n = rotation_offset[offset + x];
00644                 float sinv;
00645                 float cosv;
00646 
00647                 if (n < 32) {
00648                     sinv = sin64[n];
00649                     cosv = sin64[32 - n];
00650                 } else {
00651                     sinv =  sin64[64 -  n];
00652                     cosv = -sin64[n  - 32];
00653                 }
00654 
00655                 chgroup->decorrelation_matrix[y + x * chgroup->num_channels] =
00656                                                (v1 * sinv) - (v2 * cosv);
00657                 chgroup->decorrelation_matrix[y + i * chgroup->num_channels] =
00658                                                (v1 * cosv) + (v2 * sinv);
00659             }
00660         }
00661         offset += i;
00662     }
00663 }
00664 
00670 static int decode_channel_transform(WMAProDecodeCtx* s)
00671 {
00672     int i;
00673     /* should never consume more than 1921 bits for the 8 channel case
00674      * 1 + MAX_CHANNELS * (MAX_CHANNELS + 2 + 3 * MAX_CHANNELS * MAX_CHANNELS
00675      * + MAX_CHANNELS + MAX_BANDS + 1)
00676      */
00677 
00679     s->num_chgroups = 0;
00680     if (s->num_channels > 1) {
00681         int remaining_channels = s->channels_for_cur_subframe;
00682 
00683         if (get_bits1(&s->gb)) {
00684             av_log_ask_for_sample(s->avctx,
00685                                   "unsupported channel transform bit\n");
00686             return AVERROR_INVALIDDATA;
00687         }
00688 
00689         for (s->num_chgroups = 0; remaining_channels &&
00690              s->num_chgroups < s->channels_for_cur_subframe; s->num_chgroups++) {
00691             WMAProChannelGrp* chgroup = &s->chgroup[s->num_chgroups];
00692             float** channel_data = chgroup->channel_data;
00693             chgroup->num_channels = 0;
00694             chgroup->transform = 0;
00695 
00697             if (remaining_channels > 2) {
00698                 for (i = 0; i < s->channels_for_cur_subframe; i++) {
00699                     int channel_idx = s->channel_indexes_for_cur_subframe[i];
00700                     if (!s->channel[channel_idx].grouped
00701                         && get_bits1(&s->gb)) {
00702                         ++chgroup->num_channels;
00703                         s->channel[channel_idx].grouped = 1;
00704                         *channel_data++ = s->channel[channel_idx].coeffs;
00705                     }
00706                 }
00707             } else {
00708                 chgroup->num_channels = remaining_channels;
00709                 for (i = 0; i < s->channels_for_cur_subframe; i++) {
00710                     int channel_idx = s->channel_indexes_for_cur_subframe[i];
00711                     if (!s->channel[channel_idx].grouped)
00712                         *channel_data++ = s->channel[channel_idx].coeffs;
00713                     s->channel[channel_idx].grouped = 1;
00714                 }
00715             }
00716 
00718             if (chgroup->num_channels == 2) {
00719                 if (get_bits1(&s->gb)) {
00720                     if (get_bits1(&s->gb)) {
00721                         av_log_ask_for_sample(s->avctx,
00722                                               "unsupported channel transform type\n");
00723                     }
00724                 } else {
00725                     chgroup->transform = 1;
00726                     if (s->num_channels == 2) {
00727                         chgroup->decorrelation_matrix[0] =  1.0;
00728                         chgroup->decorrelation_matrix[1] = -1.0;
00729                         chgroup->decorrelation_matrix[2] =  1.0;
00730                         chgroup->decorrelation_matrix[3] =  1.0;
00731                     } else {
00733                         chgroup->decorrelation_matrix[0] =  0.70703125;
00734                         chgroup->decorrelation_matrix[1] = -0.70703125;
00735                         chgroup->decorrelation_matrix[2] =  0.70703125;
00736                         chgroup->decorrelation_matrix[3] =  0.70703125;
00737                     }
00738                 }
00739             } else if (chgroup->num_channels > 2) {
00740                 if (get_bits1(&s->gb)) {
00741                     chgroup->transform = 1;
00742                     if (get_bits1(&s->gb)) {
00743                         decode_decorrelation_matrix(s, chgroup);
00744                     } else {
00746                         if (chgroup->num_channels > 6) {
00747                             av_log_ask_for_sample(s->avctx,
00748                                                   "coupled channels > 6\n");
00749                         } else {
00750                             memcpy(chgroup->decorrelation_matrix,
00751                                    default_decorrelation[chgroup->num_channels],
00752                                    chgroup->num_channels * chgroup->num_channels *
00753                                    sizeof(*chgroup->decorrelation_matrix));
00754                         }
00755                     }
00756                 }
00757             }
00758 
00760             if (chgroup->transform) {
00761                 if (!get_bits1(&s->gb)) {
00762                     int i;
00764                     for (i = 0; i < s->num_bands; i++) {
00765                         chgroup->transform_band[i] = get_bits1(&s->gb);
00766                     }
00767                 } else {
00768                     memset(chgroup->transform_band, 1, s->num_bands);
00769                 }
00770             }
00771             remaining_channels -= chgroup->num_channels;
00772         }
00773     }
00774     return 0;
00775 }
00776 
00783 static int decode_coeffs(WMAProDecodeCtx *s, int c)
00784 {
00785     /* Integers 0..15 as single-precision floats.  The table saves a
00786        costly int to float conversion, and storing the values as
00787        integers allows fast sign-flipping. */
00788     static const uint32_t fval_tab[16] = {
00789         0x00000000, 0x3f800000, 0x40000000, 0x40400000,
00790         0x40800000, 0x40a00000, 0x40c00000, 0x40e00000,
00791         0x41000000, 0x41100000, 0x41200000, 0x41300000,
00792         0x41400000, 0x41500000, 0x41600000, 0x41700000,
00793     };
00794     int vlctable;
00795     VLC* vlc;
00796     WMAProChannelCtx* ci = &s->channel[c];
00797     int rl_mode = 0;
00798     int cur_coeff = 0;
00799     int num_zeros = 0;
00800     const uint16_t* run;
00801     const float* level;
00802 
00803     av_dlog(s->avctx, "decode coefficients for channel %i\n", c);
00804 
00805     vlctable = get_bits1(&s->gb);
00806     vlc = &coef_vlc[vlctable];
00807 
00808     if (vlctable) {
00809         run = coef1_run;
00810         level = coef1_level;
00811     } else {
00812         run = coef0_run;
00813         level = coef0_level;
00814     }
00815 
00818     while ((s->transmit_num_vec_coeffs || !rl_mode) &&
00819            (cur_coeff + 3 < ci->num_vec_coeffs)) {
00820         uint32_t vals[4];
00821         int i;
00822         unsigned int idx;
00823 
00824         idx = get_vlc2(&s->gb, vec4_vlc.table, VLCBITS, VEC4MAXDEPTH);
00825 
00826         if (idx == HUFF_VEC4_SIZE - 1) {
00827             for (i = 0; i < 4; i += 2) {
00828                 idx = get_vlc2(&s->gb, vec2_vlc.table, VLCBITS, VEC2MAXDEPTH);
00829                 if (idx == HUFF_VEC2_SIZE - 1) {
00830                     uint32_t v0, v1;
00831                     v0 = get_vlc2(&s->gb, vec1_vlc.table, VLCBITS, VEC1MAXDEPTH);
00832                     if (v0 == HUFF_VEC1_SIZE - 1)
00833                         v0 += ff_wma_get_large_val(&s->gb);
00834                     v1 = get_vlc2(&s->gb, vec1_vlc.table, VLCBITS, VEC1MAXDEPTH);
00835                     if (v1 == HUFF_VEC1_SIZE - 1)
00836                         v1 += ff_wma_get_large_val(&s->gb);
00837                     vals[i  ] = av_float2int(v0);
00838                     vals[i+1] = av_float2int(v1);
00839                 } else {
00840                     vals[i]   = fval_tab[symbol_to_vec2[idx] >> 4 ];
00841                     vals[i+1] = fval_tab[symbol_to_vec2[idx] & 0xF];
00842                 }
00843             }
00844         } else {
00845             vals[0] = fval_tab[ symbol_to_vec4[idx] >> 12      ];
00846             vals[1] = fval_tab[(symbol_to_vec4[idx] >> 8) & 0xF];
00847             vals[2] = fval_tab[(symbol_to_vec4[idx] >> 4) & 0xF];
00848             vals[3] = fval_tab[ symbol_to_vec4[idx]       & 0xF];
00849         }
00850 
00852         for (i = 0; i < 4; i++) {
00853             if (vals[i]) {
00854                 uint32_t sign = get_bits1(&s->gb) - 1;
00855                 AV_WN32A(&ci->coeffs[cur_coeff], vals[i] ^ sign << 31);
00856                 num_zeros = 0;
00857             } else {
00858                 ci->coeffs[cur_coeff] = 0;
00861                 rl_mode |= (++num_zeros > s->subframe_len >> 8);
00862             }
00863             ++cur_coeff;
00864         }
00865     }
00866 
00868     if (cur_coeff < s->subframe_len) {
00869         memset(&ci->coeffs[cur_coeff], 0,
00870                sizeof(*ci->coeffs) * (s->subframe_len - cur_coeff));
00871         if (ff_wma_run_level_decode(s->avctx, &s->gb, vlc,
00872                                     level, run, 1, ci->coeffs,
00873                                     cur_coeff, s->subframe_len,
00874                                     s->subframe_len, s->esc_len, 0))
00875             return AVERROR_INVALIDDATA;
00876     }
00877 
00878     return 0;
00879 }
00880 
00886 static int decode_scale_factors(WMAProDecodeCtx* s)
00887 {
00888     int i;
00889 
00894     for (i = 0; i < s->channels_for_cur_subframe; i++) {
00895         int c = s->channel_indexes_for_cur_subframe[i];
00896         int* sf;
00897         int* sf_end;
00898         s->channel[c].scale_factors = s->channel[c].saved_scale_factors[!s->channel[c].scale_factor_idx];
00899         sf_end = s->channel[c].scale_factors + s->num_bands;
00900 
00906         if (s->channel[c].reuse_sf) {
00907             const int8_t* sf_offsets = s->sf_offsets[s->table_idx][s->channel[c].table_idx];
00908             int b;
00909             for (b = 0; b < s->num_bands; b++)
00910                 s->channel[c].scale_factors[b] =
00911                     s->channel[c].saved_scale_factors[s->channel[c].scale_factor_idx][*sf_offsets++];
00912         }
00913 
00914         if (!s->channel[c].cur_subframe || get_bits1(&s->gb)) {
00915 
00916             if (!s->channel[c].reuse_sf) {
00917                 int val;
00919                 s->channel[c].scale_factor_step = get_bits(&s->gb, 2) + 1;
00920                 val = 45 / s->channel[c].scale_factor_step;
00921                 for (sf = s->channel[c].scale_factors; sf < sf_end; sf++) {
00922                     val += get_vlc2(&s->gb, sf_vlc.table, SCALEVLCBITS, SCALEMAXDEPTH) - 60;
00923                     *sf = val;
00924                 }
00925             } else {
00926                 int i;
00928                 for (i = 0; i < s->num_bands; i++) {
00929                     int idx;
00930                     int skip;
00931                     int val;
00932                     int sign;
00933 
00934                     idx = get_vlc2(&s->gb, sf_rl_vlc.table, VLCBITS, SCALERLMAXDEPTH);
00935 
00936                     if (!idx) {
00937                         uint32_t code = get_bits(&s->gb, 14);
00938                         val  =  code >> 6;
00939                         sign = (code & 1) - 1;
00940                         skip = (code & 0x3f) >> 1;
00941                     } else if (idx == 1) {
00942                         break;
00943                     } else {
00944                         skip = scale_rl_run[idx];
00945                         val  = scale_rl_level[idx];
00946                         sign = get_bits1(&s->gb)-1;
00947                     }
00948 
00949                     i += skip;
00950                     if (i >= s->num_bands) {
00951                         av_log(s->avctx, AV_LOG_ERROR,
00952                                "invalid scale factor coding\n");
00953                         return AVERROR_INVALIDDATA;
00954                     }
00955                     s->channel[c].scale_factors[i] += (val ^ sign) - sign;
00956                 }
00957             }
00959             s->channel[c].scale_factor_idx = !s->channel[c].scale_factor_idx;
00960             s->channel[c].table_idx = s->table_idx;
00961             s->channel[c].reuse_sf  = 1;
00962         }
00963 
00965         s->channel[c].max_scale_factor = s->channel[c].scale_factors[0];
00966         for (sf = s->channel[c].scale_factors + 1; sf < sf_end; sf++) {
00967             s->channel[c].max_scale_factor =
00968                 FFMAX(s->channel[c].max_scale_factor, *sf);
00969         }
00970 
00971     }
00972     return 0;
00973 }
00974 
00979 static void inverse_channel_transform(WMAProDecodeCtx *s)
00980 {
00981     int i;
00982 
00983     for (i = 0; i < s->num_chgroups; i++) {
00984         if (s->chgroup[i].transform) {
00985             float data[WMAPRO_MAX_CHANNELS];
00986             const int num_channels = s->chgroup[i].num_channels;
00987             float** ch_data = s->chgroup[i].channel_data;
00988             float** ch_end = ch_data + num_channels;
00989             const int8_t* tb = s->chgroup[i].transform_band;
00990             int16_t* sfb;
00991 
00993             for (sfb = s->cur_sfb_offsets;
00994                  sfb < s->cur_sfb_offsets + s->num_bands; sfb++) {
00995                 int y;
00996                 if (*tb++ == 1) {
00998                     for (y = sfb[0]; y < FFMIN(sfb[1], s->subframe_len); y++) {
00999                         const float* mat = s->chgroup[i].decorrelation_matrix;
01000                         const float* data_end = data + num_channels;
01001                         float* data_ptr = data;
01002                         float** ch;
01003 
01004                         for (ch = ch_data; ch < ch_end; ch++)
01005                             *data_ptr++ = (*ch)[y];
01006 
01007                         for (ch = ch_data; ch < ch_end; ch++) {
01008                             float sum = 0;
01009                             data_ptr = data;
01010                             while (data_ptr < data_end)
01011                                 sum += *data_ptr++ * *mat++;
01012 
01013                             (*ch)[y] = sum;
01014                         }
01015                     }
01016                 } else if (s->num_channels == 2) {
01017                     int len = FFMIN(sfb[1], s->subframe_len) - sfb[0];
01018                     s->dsp.vector_fmul_scalar(ch_data[0] + sfb[0],
01019                                               ch_data[0] + sfb[0],
01020                                               181.0 / 128, len);
01021                     s->dsp.vector_fmul_scalar(ch_data[1] + sfb[0],
01022                                               ch_data[1] + sfb[0],
01023                                               181.0 / 128, len);
01024                 }
01025             }
01026         }
01027     }
01028 }
01029 
01034 static void wmapro_window(WMAProDecodeCtx *s)
01035 {
01036     int i;
01037     for (i = 0; i < s->channels_for_cur_subframe; i++) {
01038         int c = s->channel_indexes_for_cur_subframe[i];
01039         float* window;
01040         int winlen = s->channel[c].prev_block_len;
01041         float* start = s->channel[c].coeffs - (winlen >> 1);
01042 
01043         if (s->subframe_len < winlen) {
01044             start += (winlen - s->subframe_len) >> 1;
01045             winlen = s->subframe_len;
01046         }
01047 
01048         window = s->windows[av_log2(winlen) - WMAPRO_BLOCK_MIN_BITS];
01049 
01050         winlen >>= 1;
01051 
01052         s->dsp.vector_fmul_window(start, start, start + winlen,
01053                                   window, winlen);
01054 
01055         s->channel[c].prev_block_len = s->subframe_len;
01056     }
01057 }
01058 
01064 static int decode_subframe(WMAProDecodeCtx *s)
01065 {
01066     int offset = s->samples_per_frame;
01067     int subframe_len = s->samples_per_frame;
01068     int i;
01069     int total_samples   = s->samples_per_frame * s->num_channels;
01070     int transmit_coeffs = 0;
01071     int cur_subwoofer_cutoff;
01072 
01073     s->subframe_offset = get_bits_count(&s->gb);
01074 
01079     for (i = 0; i < s->num_channels; i++) {
01080         s->channel[i].grouped = 0;
01081         if (offset > s->channel[i].decoded_samples) {
01082             offset = s->channel[i].decoded_samples;
01083             subframe_len =
01084                 s->channel[i].subframe_len[s->channel[i].cur_subframe];
01085         }
01086     }
01087 
01088     av_dlog(s->avctx,
01089             "processing subframe with offset %i len %i\n", offset, subframe_len);
01090 
01092     s->channels_for_cur_subframe = 0;
01093     for (i = 0; i < s->num_channels; i++) {
01094         const int cur_subframe = s->channel[i].cur_subframe;
01096         total_samples -= s->channel[i].decoded_samples;
01097 
01099         if (offset == s->channel[i].decoded_samples &&
01100             subframe_len == s->channel[i].subframe_len[cur_subframe]) {
01101             total_samples -= s->channel[i].subframe_len[cur_subframe];
01102             s->channel[i].decoded_samples +=
01103                 s->channel[i].subframe_len[cur_subframe];
01104             s->channel_indexes_for_cur_subframe[s->channels_for_cur_subframe] = i;
01105             ++s->channels_for_cur_subframe;
01106         }
01107     }
01108 
01111     if (!total_samples)
01112         s->parsed_all_subframes = 1;
01113 
01114 
01115     av_dlog(s->avctx, "subframe is part of %i channels\n",
01116             s->channels_for_cur_subframe);
01117 
01119     s->table_idx         = av_log2(s->samples_per_frame/subframe_len);
01120     s->num_bands         = s->num_sfb[s->table_idx];
01121     s->cur_sfb_offsets   = s->sfb_offsets[s->table_idx];
01122     cur_subwoofer_cutoff = s->subwoofer_cutoffs[s->table_idx];
01123 
01125     for (i = 0; i < s->channels_for_cur_subframe; i++) {
01126         int c = s->channel_indexes_for_cur_subframe[i];
01127 
01128         s->channel[c].coeffs = &s->channel[c].out[(s->samples_per_frame >> 1)
01129                                                   + offset];
01130     }
01131 
01132     s->subframe_len = subframe_len;
01133     s->esc_len = av_log2(s->subframe_len - 1) + 1;
01134 
01136     if (get_bits1(&s->gb)) {
01137         int num_fill_bits;
01138         if (!(num_fill_bits = get_bits(&s->gb, 2))) {
01139             int len = get_bits(&s->gb, 4);
01140             num_fill_bits = get_bits(&s->gb, len) + 1;
01141         }
01142 
01143         if (num_fill_bits >= 0) {
01144             if (get_bits_count(&s->gb) + num_fill_bits > s->num_saved_bits) {
01145                 av_log(s->avctx, AV_LOG_ERROR, "invalid number of fill bits\n");
01146                 return AVERROR_INVALIDDATA;
01147             }
01148 
01149             skip_bits_long(&s->gb, num_fill_bits);
01150         }
01151     }
01152 
01154     if (get_bits1(&s->gb)) {
01155         av_log_ask_for_sample(s->avctx, "reserved bit set\n");
01156         return AVERROR_INVALIDDATA;
01157     }
01158 
01159 
01160     if (decode_channel_transform(s) < 0)
01161         return AVERROR_INVALIDDATA;
01162 
01163 
01164     for (i = 0; i < s->channels_for_cur_subframe; i++) {
01165         int c = s->channel_indexes_for_cur_subframe[i];
01166         if ((s->channel[c].transmit_coefs = get_bits1(&s->gb)))
01167             transmit_coeffs = 1;
01168     }
01169 
01170     if (transmit_coeffs) {
01171         int step;
01172         int quant_step = 90 * s->bits_per_sample >> 4;
01173 
01175         if ((s->transmit_num_vec_coeffs = get_bits1(&s->gb))) {
01176             int num_bits = av_log2((s->subframe_len + 3)/4) + 1;
01177             for (i = 0; i < s->channels_for_cur_subframe; i++) {
01178                 int c = s->channel_indexes_for_cur_subframe[i];
01179                 int num_vec_coeffs = get_bits(&s->gb, num_bits) << 2;
01180                 if (num_vec_coeffs > WMAPRO_BLOCK_MAX_SIZE) {
01181                     av_log(s->avctx, AV_LOG_ERROR, "num_vec_coeffs %d is too large\n", num_vec_coeffs);
01182                     return AVERROR_INVALIDDATA;
01183                 }
01184                 s->channel[c].num_vec_coeffs = num_vec_coeffs;
01185             }
01186         } else {
01187             for (i = 0; i < s->channels_for_cur_subframe; i++) {
01188                 int c = s->channel_indexes_for_cur_subframe[i];
01189                 s->channel[c].num_vec_coeffs = s->subframe_len;
01190             }
01191         }
01193         step = get_sbits(&s->gb, 6);
01194         quant_step += step;
01195         if (step == -32 || step == 31) {
01196             const int sign = (step == 31) - 1;
01197             int quant = 0;
01198             while (get_bits_count(&s->gb) + 5 < s->num_saved_bits &&
01199                    (step = get_bits(&s->gb, 5)) == 31) {
01200                 quant += 31;
01201             }
01202             quant_step += ((quant + step) ^ sign) - sign;
01203         }
01204         if (quant_step < 0) {
01205             av_log(s->avctx, AV_LOG_DEBUG, "negative quant step\n");
01206         }
01207 
01210         if (s->channels_for_cur_subframe == 1) {
01211             s->channel[s->channel_indexes_for_cur_subframe[0]].quant_step = quant_step;
01212         } else {
01213             int modifier_len = get_bits(&s->gb, 3);
01214             for (i = 0; i < s->channels_for_cur_subframe; i++) {
01215                 int c = s->channel_indexes_for_cur_subframe[i];
01216                 s->channel[c].quant_step = quant_step;
01217                 if (get_bits1(&s->gb)) {
01218                     if (modifier_len) {
01219                         s->channel[c].quant_step += get_bits(&s->gb, modifier_len) + 1;
01220                     } else
01221                         ++s->channel[c].quant_step;
01222                 }
01223             }
01224         }
01225 
01227         if (decode_scale_factors(s) < 0)
01228             return AVERROR_INVALIDDATA;
01229     }
01230 
01231     av_dlog(s->avctx, "BITSTREAM: subframe header length was %i\n",
01232             get_bits_count(&s->gb) - s->subframe_offset);
01233 
01235     for (i = 0; i < s->channels_for_cur_subframe; i++) {
01236         int c = s->channel_indexes_for_cur_subframe[i];
01237         if (s->channel[c].transmit_coefs &&
01238             get_bits_count(&s->gb) < s->num_saved_bits) {
01239             decode_coeffs(s, c);
01240         } else
01241             memset(s->channel[c].coeffs, 0,
01242                    sizeof(*s->channel[c].coeffs) * subframe_len);
01243     }
01244 
01245     av_dlog(s->avctx, "BITSTREAM: subframe length was %i\n",
01246             get_bits_count(&s->gb) - s->subframe_offset);
01247 
01248     if (transmit_coeffs) {
01249         FFTContext *mdct = &s->mdct_ctx[av_log2(subframe_len) - WMAPRO_BLOCK_MIN_BITS];
01251         inverse_channel_transform(s);
01252         for (i = 0; i < s->channels_for_cur_subframe; i++) {
01253             int c = s->channel_indexes_for_cur_subframe[i];
01254             const int* sf = s->channel[c].scale_factors;
01255             int b;
01256 
01257             if (c == s->lfe_channel)
01258                 memset(&s->tmp[cur_subwoofer_cutoff], 0, sizeof(*s->tmp) *
01259                        (subframe_len - cur_subwoofer_cutoff));
01260 
01262             for (b = 0; b < s->num_bands; b++) {
01263                 const int end = FFMIN(s->cur_sfb_offsets[b+1], s->subframe_len);
01264                 const int exp = s->channel[c].quant_step -
01265                             (s->channel[c].max_scale_factor - *sf++) *
01266                             s->channel[c].scale_factor_step;
01267                 const float quant = pow(10.0, exp / 20.0);
01268                 int start = s->cur_sfb_offsets[b];
01269                 s->dsp.vector_fmul_scalar(s->tmp + start,
01270                                           s->channel[c].coeffs + start,
01271                                           quant, end - start);
01272             }
01273 
01275             mdct->imdct_half(mdct, s->channel[c].coeffs, s->tmp);
01276         }
01277     }
01278 
01280     wmapro_window(s);
01281 
01283     for (i = 0; i < s->channels_for_cur_subframe; i++) {
01284         int c = s->channel_indexes_for_cur_subframe[i];
01285         if (s->channel[c].cur_subframe >= s->channel[c].num_subframes) {
01286             av_log(s->avctx, AV_LOG_ERROR, "broken subframe\n");
01287             return AVERROR_INVALIDDATA;
01288         }
01289         ++s->channel[c].cur_subframe;
01290     }
01291 
01292     return 0;
01293 }
01294 
01301 static int decode_frame(WMAProDecodeCtx *s, int *got_frame_ptr)
01302 {
01303     AVCodecContext *avctx = s->avctx;
01304     GetBitContext* gb = &s->gb;
01305     int more_frames = 0;
01306     int len = 0;
01307     int i, ret;
01308     const float *out_ptr[WMAPRO_MAX_CHANNELS];
01309     float *samples;
01310 
01312     if (s->len_prefix)
01313         len = get_bits(gb, s->log2_frame_size);
01314 
01315     av_dlog(s->avctx, "decoding frame with length %x\n", len);
01316 
01318     if (decode_tilehdr(s)) {
01319         s->packet_loss = 1;
01320         return 0;
01321     }
01322 
01324     if (s->num_channels > 1 && get_bits1(gb)) {
01325         if (get_bits1(gb)) {
01326             for (i = 0; i < s->num_channels * s->num_channels; i++)
01327                 skip_bits(gb, 4);
01328         }
01329     }
01330 
01332     if (s->dynamic_range_compression) {
01333         s->drc_gain = get_bits(gb, 8);
01334         av_dlog(s->avctx, "drc_gain %i\n", s->drc_gain);
01335     }
01336 
01339     if (get_bits1(gb)) {
01340         int av_unused skip;
01341 
01343         if (get_bits1(gb)) {
01344             skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
01345             av_dlog(s->avctx, "start skip: %i\n", skip);
01346         }
01347 
01349         if (get_bits1(gb)) {
01350             skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
01351             av_dlog(s->avctx, "end skip: %i\n", skip);
01352         }
01353 
01354     }
01355 
01356     av_dlog(s->avctx, "BITSTREAM: frame header length was %i\n",
01357             get_bits_count(gb) - s->frame_offset);
01358 
01360     s->parsed_all_subframes = 0;
01361     for (i = 0; i < s->num_channels; i++) {
01362         s->channel[i].decoded_samples = 0;
01363         s->channel[i].cur_subframe    = 0;
01364         s->channel[i].reuse_sf        = 0;
01365     }
01366 
01368     while (!s->parsed_all_subframes) {
01369         if (decode_subframe(s) < 0) {
01370             s->packet_loss = 1;
01371             return 0;
01372         }
01373     }
01374 
01375     /* get output buffer */
01376     s->frame.nb_samples = s->samples_per_frame;
01377     if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
01378         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
01379         s->packet_loss = 1;
01380         return 0;
01381     }
01382     samples = (float *)s->frame.data[0];
01383 
01385     for (i = 0; i < s->num_channels; i++)
01386         out_ptr[i] = s->channel[i].out;
01387     s->fmt_conv.float_interleave(samples, out_ptr, s->samples_per_frame,
01388                                  s->num_channels);
01389 
01390     for (i = 0; i < s->num_channels; i++) {
01392         memcpy(&s->channel[i].out[0],
01393                &s->channel[i].out[s->samples_per_frame],
01394                s->samples_per_frame * sizeof(*s->channel[i].out) >> 1);
01395     }
01396 
01397     if (s->skip_frame) {
01398         s->skip_frame = 0;
01399         *got_frame_ptr = 0;
01400     } else {
01401         *got_frame_ptr = 1;
01402     }
01403 
01404     if (s->len_prefix) {
01405         if (len != (get_bits_count(gb) - s->frame_offset) + 2) {
01407             av_log(s->avctx, AV_LOG_ERROR,
01408                    "frame[%i] would have to skip %i bits\n", s->frame_num,
01409                    len - (get_bits_count(gb) - s->frame_offset) - 1);
01410             s->packet_loss = 1;
01411             return 0;
01412         }
01413 
01415         skip_bits_long(gb, len - (get_bits_count(gb) - s->frame_offset) - 1);
01416     } else {
01417         while (get_bits_count(gb) < s->num_saved_bits && get_bits1(gb) == 0) {
01418         }
01419     }
01420 
01422     more_frames = get_bits1(gb);
01423 
01424     ++s->frame_num;
01425     return more_frames;
01426 }
01427 
01434 static int remaining_bits(WMAProDecodeCtx *s, GetBitContext *gb)
01435 {
01436     return s->buf_bit_size - get_bits_count(gb);
01437 }
01438 
01446 static void save_bits(WMAProDecodeCtx *s, GetBitContext* gb, int len,
01447                       int append)
01448 {
01449     int buflen;
01450 
01455     if (!append) {
01456         s->frame_offset = get_bits_count(gb) & 7;
01457         s->num_saved_bits = s->frame_offset;
01458         init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE);
01459     }
01460 
01461     buflen = (s->num_saved_bits + len + 8) >> 3;
01462 
01463     if (len <= 0 || buflen > MAX_FRAMESIZE) {
01464         av_log_ask_for_sample(s->avctx, "input buffer too small\n");
01465         s->packet_loss = 1;
01466         return;
01467     }
01468 
01469     s->num_saved_bits += len;
01470     if (!append) {
01471         avpriv_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3),
01472                      s->num_saved_bits);
01473     } else {
01474         int align = 8 - (get_bits_count(gb) & 7);
01475         align = FFMIN(align, len);
01476         put_bits(&s->pb, align, get_bits(gb, align));
01477         len -= align;
01478         avpriv_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3), len);
01479     }
01480     skip_bits_long(gb, len);
01481 
01482     {
01483         PutBitContext tmp = s->pb;
01484         flush_put_bits(&tmp);
01485     }
01486 
01487     init_get_bits(&s->gb, s->frame_data, s->num_saved_bits);
01488     skip_bits(&s->gb, s->frame_offset);
01489 }
01490 
01499 static int decode_packet(AVCodecContext *avctx, void *data,
01500                          int *got_frame_ptr, AVPacket* avpkt)
01501 {
01502     WMAProDecodeCtx *s = avctx->priv_data;
01503     GetBitContext* gb  = &s->pgb;
01504     const uint8_t* buf = avpkt->data;
01505     int buf_size       = avpkt->size;
01506     int num_bits_prev_frame;
01507     int packet_sequence_number;
01508 
01509     *got_frame_ptr = 0;
01510 
01511     if (s->packet_done || s->packet_loss) {
01512         s->packet_done = 0;
01513 
01515         if (buf_size < avctx->block_align) {
01516             av_log(avctx, AV_LOG_ERROR, "Input packet too small (%d < %d)\n",
01517                    buf_size, avctx->block_align);
01518             return AVERROR_INVALIDDATA;
01519         }
01520 
01521         s->next_packet_start = buf_size - avctx->block_align;
01522         buf_size = avctx->block_align;
01523         s->buf_bit_size = buf_size << 3;
01524 
01526         init_get_bits(gb, buf, s->buf_bit_size);
01527         packet_sequence_number = get_bits(gb, 4);
01528         skip_bits(gb, 2);
01529 
01531         num_bits_prev_frame = get_bits(gb, s->log2_frame_size);
01532         av_dlog(avctx, "packet[%d]: nbpf %x\n", avctx->frame_number,
01533                 num_bits_prev_frame);
01534 
01536         if (!s->packet_loss &&
01537             ((s->packet_sequence_number + 1) & 0xF) != packet_sequence_number) {
01538             s->packet_loss = 1;
01539             av_log(avctx, AV_LOG_ERROR, "Packet loss detected! seq %x vs %x\n",
01540                    s->packet_sequence_number, packet_sequence_number);
01541         }
01542         s->packet_sequence_number = packet_sequence_number;
01543 
01544         if (num_bits_prev_frame > 0) {
01545             int remaining_packet_bits = s->buf_bit_size - get_bits_count(gb);
01546             if (num_bits_prev_frame >= remaining_packet_bits) {
01547                 num_bits_prev_frame = remaining_packet_bits;
01548                 s->packet_done = 1;
01549             }
01550 
01553             save_bits(s, gb, num_bits_prev_frame, 1);
01554             av_dlog(avctx, "accumulated %x bits of frame data\n",
01555                     s->num_saved_bits - s->frame_offset);
01556 
01558             if (!s->packet_loss)
01559                 decode_frame(s, got_frame_ptr);
01560         } else if (s->num_saved_bits - s->frame_offset) {
01561             av_dlog(avctx, "ignoring %x previously saved bits\n",
01562                     s->num_saved_bits - s->frame_offset);
01563         }
01564 
01565         if (s->packet_loss) {
01569             s->num_saved_bits = 0;
01570             s->packet_loss = 0;
01571         }
01572 
01573     } else {
01574         int frame_size;
01575         s->buf_bit_size = (avpkt->size - s->next_packet_start) << 3;
01576         init_get_bits(gb, avpkt->data, s->buf_bit_size);
01577         skip_bits(gb, s->packet_offset);
01578         if (s->len_prefix && remaining_bits(s, gb) > s->log2_frame_size &&
01579             (frame_size = show_bits(gb, s->log2_frame_size)) &&
01580             frame_size <= remaining_bits(s, gb)) {
01581             save_bits(s, gb, frame_size, 0);
01582             s->packet_done = !decode_frame(s, got_frame_ptr);
01583         } else if (!s->len_prefix
01584                    && s->num_saved_bits > get_bits_count(&s->gb)) {
01592             s->packet_done = !decode_frame(s, got_frame_ptr);
01593         } else
01594             s->packet_done = 1;
01595     }
01596 
01597     if (s->packet_done && !s->packet_loss &&
01598         remaining_bits(s, gb) > 0) {
01601         save_bits(s, gb, remaining_bits(s, gb), 0);
01602     }
01603 
01604     s->packet_offset = get_bits_count(gb) & 7;
01605     if (s->packet_loss)
01606         return AVERROR_INVALIDDATA;
01607 
01608     if (*got_frame_ptr)
01609         *(AVFrame *)data = s->frame;
01610 
01611     return get_bits_count(gb) >> 3;
01612 }
01613 
01618 static void flush(AVCodecContext *avctx)
01619 {
01620     WMAProDecodeCtx *s = avctx->priv_data;
01621     int i;
01624     for (i = 0; i < s->num_channels; i++)
01625         memset(s->channel[i].out, 0, s->samples_per_frame *
01626                sizeof(*s->channel[i].out));
01627     s->packet_loss = 1;
01628 }
01629 
01630 
01634 AVCodec ff_wmapro_decoder = {
01635     .name           = "wmapro",
01636     .type           = AVMEDIA_TYPE_AUDIO,
01637     .id             = CODEC_ID_WMAPRO,
01638     .priv_data_size = sizeof(WMAProDecodeCtx),
01639     .init           = decode_init,
01640     .close          = decode_end,
01641     .decode         = decode_packet,
01642     .capabilities   = CODEC_CAP_SUBFRAMES | CODEC_CAP_DR1,
01643     .flush= flush,
01644     .long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio 9 Professional"),
01645 };
Generated on Thu Jul 11 2013 15:38:22 for Libav by doxygen 1.7.1