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

libavcodec/mlpdec.c

Go to the documentation of this file.
00001 /*
00002  * MLP decoder
00003  * Copyright (c) 2007-2008 Ian Caulfield
00004  *
00005  * This file is part of FFmpeg.
00006  *
00007  * FFmpeg is free software; you can redistribute it and/or
00008  * modify it under the terms of the GNU Lesser General Public
00009  * License as published by the Free Software Foundation; either
00010  * version 2.1 of the License, or (at your option) any later version.
00011  *
00012  * FFmpeg is distributed in the hope that it will be useful,
00013  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00014  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00015  * Lesser General Public License for more details.
00016  *
00017  * You should have received a copy of the GNU Lesser General Public
00018  * License along with FFmpeg; if not, write to the Free Software
00019  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
00020  */
00021 
00027 #include <stdint.h>
00028 
00029 #include "avcodec.h"
00030 #include "dsputil.h"
00031 #include "libavutil/intreadwrite.h"
00032 #include "get_bits.h"
00033 #include "libavutil/crc.h"
00034 #include "parser.h"
00035 #include "mlp_parser.h"
00036 #include "mlp.h"
00037 
00039 #define VLC_BITS            9
00040 
00041 
00042 static const char* sample_message =
00043     "Please file a bug report following the instructions at "
00044     "http://ffmpeg.org/bugreports.html and include "
00045     "a sample of this file.";
00046 
00047 typedef struct SubStream {
00049     uint8_t     restart_seen;
00050 
00052 
00053 
00054     uint16_t    noise_type;
00055 
00057     uint8_t     min_channel;
00059     uint8_t     max_channel;
00061     uint8_t     max_matrix_channel;
00063     uint8_t     ch_assign[MAX_CHANNELS];
00064 
00066     ChannelParams channel_params[MAX_CHANNELS];
00067 
00069     uint8_t     noise_shift;
00071     uint32_t    noisegen_seed;
00072 
00074     uint8_t     data_check_present;
00075 
00077     uint8_t     param_presence_flags;
00078 #define PARAM_BLOCKSIZE     (1 << 7)
00079 #define PARAM_MATRIX        (1 << 6)
00080 #define PARAM_OUTSHIFT      (1 << 5)
00081 #define PARAM_QUANTSTEP     (1 << 4)
00082 #define PARAM_FIR           (1 << 3)
00083 #define PARAM_IIR           (1 << 2)
00084 #define PARAM_HUFFOFFSET    (1 << 1)
00085 #define PARAM_PRESENCE      (1 << 0)
00086 
00087 
00089 
00091 
00092     uint8_t     num_primitive_matrices;
00093 
00095     uint8_t     matrix_out_ch[MAX_MATRICES];
00096 
00098     uint8_t     lsb_bypass[MAX_MATRICES];
00100     int32_t     matrix_coeff[MAX_MATRICES][MAX_CHANNELS];
00102     uint8_t     matrix_noise_shift[MAX_MATRICES];
00104 
00106     uint8_t     quant_step_size[MAX_CHANNELS];
00107 
00109     uint16_t    blocksize;
00111     uint16_t    blockpos;
00112 
00114     int8_t      output_shift[MAX_CHANNELS];
00115 
00117     int32_t     lossless_check_data;
00118 
00119 } SubStream;
00120 
00121 typedef struct MLPDecodeContext {
00122     AVCodecContext *avctx;
00123 
00125     int         is_major_sync_unit;
00126 
00128     uint8_t     params_valid;
00129 
00131     uint8_t     num_substreams;
00132 
00134     uint8_t     max_decoded_substream;
00135 
00137     int         access_unit_size;
00139     int         access_unit_size_pow2;
00140 
00141     SubStream   substream[MAX_SUBSTREAMS];
00142 
00143     int         matrix_changed;
00144     int         filter_changed[MAX_CHANNELS][NUM_FILTERS];
00145 
00146     int8_t      noise_buffer[MAX_BLOCKSIZE_POW2];
00147     int8_t      bypassed_lsbs[MAX_BLOCKSIZE][MAX_CHANNELS];
00148     int32_t     sample_buffer[MAX_BLOCKSIZE][MAX_CHANNELS];
00149 
00150     DSPContext  dsp;
00151 } MLPDecodeContext;
00152 
00153 static VLC huff_vlc[3];
00154 
00157 static av_cold void init_static(void)
00158 {
00159     if (!huff_vlc[0].bits) {
00160         INIT_VLC_STATIC(&huff_vlc[0], VLC_BITS, 18,
00161                     &ff_mlp_huffman_tables[0][0][1], 2, 1,
00162                     &ff_mlp_huffman_tables[0][0][0], 2, 1, 512);
00163         INIT_VLC_STATIC(&huff_vlc[1], VLC_BITS, 16,
00164                     &ff_mlp_huffman_tables[1][0][1], 2, 1,
00165                     &ff_mlp_huffman_tables[1][0][0], 2, 1, 512);
00166         INIT_VLC_STATIC(&huff_vlc[2], VLC_BITS, 15,
00167                     &ff_mlp_huffman_tables[2][0][1], 2, 1,
00168                     &ff_mlp_huffman_tables[2][0][0], 2, 1, 512);
00169     }
00170 
00171     ff_mlp_init_crc();
00172 }
00173 
00174 static inline int32_t calculate_sign_huff(MLPDecodeContext *m,
00175                                           unsigned int substr, unsigned int ch)
00176 {
00177     SubStream *s = &m->substream[substr];
00178     ChannelParams *cp = &s->channel_params[ch];
00179     int lsb_bits = cp->huff_lsbs - s->quant_step_size[ch];
00180     int sign_shift = lsb_bits + (cp->codebook ? 2 - cp->codebook : -1);
00181     int32_t sign_huff_offset = cp->huff_offset;
00182 
00183     if (cp->codebook > 0)
00184         sign_huff_offset -= 7 << lsb_bits;
00185 
00186     if (sign_shift >= 0)
00187         sign_huff_offset -= 1 << sign_shift;
00188 
00189     return sign_huff_offset;
00190 }
00191 
00195 static inline int read_huff_channels(MLPDecodeContext *m, GetBitContext *gbp,
00196                                      unsigned int substr, unsigned int pos)
00197 {
00198     SubStream *s = &m->substream[substr];
00199     unsigned int mat, channel;
00200 
00201     for (mat = 0; mat < s->num_primitive_matrices; mat++)
00202         if (s->lsb_bypass[mat])
00203             m->bypassed_lsbs[pos + s->blockpos][mat] = get_bits1(gbp);
00204 
00205     for (channel = s->min_channel; channel <= s->max_channel; channel++) {
00206         ChannelParams *cp = &s->channel_params[channel];
00207         int codebook = cp->codebook;
00208         int quant_step_size = s->quant_step_size[channel];
00209         int lsb_bits = cp->huff_lsbs - quant_step_size;
00210         int result = 0;
00211 
00212         if (codebook > 0)
00213             result = get_vlc2(gbp, huff_vlc[codebook-1].table,
00214                             VLC_BITS, (9 + VLC_BITS - 1) / VLC_BITS);
00215 
00216         if (result < 0)
00217             return -1;
00218 
00219         if (lsb_bits > 0)
00220             result = (result << lsb_bits) + get_bits(gbp, lsb_bits);
00221 
00222         result  += cp->sign_huff_offset;
00223         result <<= quant_step_size;
00224 
00225         m->sample_buffer[pos + s->blockpos][channel] = result;
00226     }
00227 
00228     return 0;
00229 }
00230 
00231 static av_cold int mlp_decode_init(AVCodecContext *avctx)
00232 {
00233     MLPDecodeContext *m = avctx->priv_data;
00234     int substr;
00235 
00236     init_static();
00237     m->avctx = avctx;
00238     for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
00239         m->substream[substr].lossless_check_data = 0xffffffff;
00240     dsputil_init(&m->dsp, avctx);
00241 
00242     return 0;
00243 }
00244 
00250 static int read_major_sync(MLPDecodeContext *m, GetBitContext *gb)
00251 {
00252     MLPHeaderInfo mh;
00253     int substr;
00254 
00255     if (ff_mlp_read_major_sync(m->avctx, &mh, gb) != 0)
00256         return -1;
00257 
00258     if (mh.group1_bits == 0) {
00259         av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown bits per sample\n");
00260         return -1;
00261     }
00262     if (mh.group2_bits > mh.group1_bits) {
00263         av_log(m->avctx, AV_LOG_ERROR,
00264                "Channel group 2 cannot have more bits per sample than group 1.\n");
00265         return -1;
00266     }
00267 
00268     if (mh.group2_samplerate && mh.group2_samplerate != mh.group1_samplerate) {
00269         av_log(m->avctx, AV_LOG_ERROR,
00270                "Channel groups with differing sample rates are not currently supported.\n");
00271         return -1;
00272     }
00273 
00274     if (mh.group1_samplerate == 0) {
00275         av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown sampling rate\n");
00276         return -1;
00277     }
00278     if (mh.group1_samplerate > MAX_SAMPLERATE) {
00279         av_log(m->avctx, AV_LOG_ERROR,
00280                "Sampling rate %d is greater than the supported maximum (%d).\n",
00281                mh.group1_samplerate, MAX_SAMPLERATE);
00282         return -1;
00283     }
00284     if (mh.access_unit_size > MAX_BLOCKSIZE) {
00285         av_log(m->avctx, AV_LOG_ERROR,
00286                "Block size %d is greater than the supported maximum (%d).\n",
00287                mh.access_unit_size, MAX_BLOCKSIZE);
00288         return -1;
00289     }
00290     if (mh.access_unit_size_pow2 > MAX_BLOCKSIZE_POW2) {
00291         av_log(m->avctx, AV_LOG_ERROR,
00292                "Block size pow2 %d is greater than the supported maximum (%d).\n",
00293                mh.access_unit_size_pow2, MAX_BLOCKSIZE_POW2);
00294         return -1;
00295     }
00296 
00297     if (mh.num_substreams == 0)
00298         return -1;
00299     if (m->avctx->codec_id == CODEC_ID_MLP && mh.num_substreams > 2) {
00300         av_log(m->avctx, AV_LOG_ERROR, "MLP only supports up to 2 substreams.\n");
00301         return -1;
00302     }
00303     if (mh.num_substreams > MAX_SUBSTREAMS) {
00304         av_log(m->avctx, AV_LOG_ERROR,
00305                "Number of substreams %d is larger than the maximum supported "
00306                "by the decoder. %s\n", mh.num_substreams, sample_message);
00307         return -1;
00308     }
00309 
00310     m->access_unit_size      = mh.access_unit_size;
00311     m->access_unit_size_pow2 = mh.access_unit_size_pow2;
00312 
00313     m->num_substreams        = mh.num_substreams;
00314     m->max_decoded_substream = m->num_substreams - 1;
00315 
00316     m->avctx->sample_rate    = mh.group1_samplerate;
00317     m->avctx->frame_size     = mh.access_unit_size;
00318 
00319     m->avctx->bits_per_raw_sample = mh.group1_bits;
00320     if (mh.group1_bits > 16)
00321         m->avctx->sample_fmt = SAMPLE_FMT_S32;
00322     else
00323         m->avctx->sample_fmt = SAMPLE_FMT_S16;
00324 
00325     m->params_valid = 1;
00326     for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
00327         m->substream[substr].restart_seen = 0;
00328 
00329     return 0;
00330 }
00331 
00336 static int read_restart_header(MLPDecodeContext *m, GetBitContext *gbp,
00337                                const uint8_t *buf, unsigned int substr)
00338 {
00339     SubStream *s = &m->substream[substr];
00340     unsigned int ch;
00341     int sync_word, tmp;
00342     uint8_t checksum;
00343     uint8_t lossless_check;
00344     int start_count = get_bits_count(gbp);
00345     const int max_matrix_channel = m->avctx->codec_id == CODEC_ID_MLP
00346                                  ? MAX_MATRIX_CHANNEL_MLP
00347                                  : MAX_MATRIX_CHANNEL_TRUEHD;
00348 
00349     sync_word = get_bits(gbp, 13);
00350 
00351     if (sync_word != 0x31ea >> 1) {
00352         av_log(m->avctx, AV_LOG_ERROR,
00353                "restart header sync incorrect (got 0x%04x)\n", sync_word);
00354         return -1;
00355     }
00356 
00357     s->noise_type = get_bits1(gbp);
00358 
00359     if (m->avctx->codec_id == CODEC_ID_MLP && s->noise_type) {
00360         av_log(m->avctx, AV_LOG_ERROR, "MLP must have 0x31ea sync word.\n");
00361         return -1;
00362     }
00363 
00364     skip_bits(gbp, 16); /* Output timestamp */
00365 
00366     s->min_channel        = get_bits(gbp, 4);
00367     s->max_channel        = get_bits(gbp, 4);
00368     s->max_matrix_channel = get_bits(gbp, 4);
00369 
00370     if (s->max_matrix_channel > max_matrix_channel) {
00371         av_log(m->avctx, AV_LOG_ERROR,
00372                "Max matrix channel cannot be greater than %d.\n",
00373                max_matrix_channel);
00374         return -1;
00375     }
00376 
00377     if (s->max_channel != s->max_matrix_channel) {
00378         av_log(m->avctx, AV_LOG_ERROR,
00379                "Max channel must be equal max matrix channel.\n");
00380         return -1;
00381     }
00382 
00383     /* This should happen for TrueHD streams with >6 channels and MLP's noise
00384      * type. It is not yet known if this is allowed. */
00385     if (s->max_channel > MAX_MATRIX_CHANNEL_MLP && !s->noise_type) {
00386         av_log(m->avctx, AV_LOG_ERROR,
00387                "Number of channels %d is larger than the maximum supported "
00388                "by the decoder. %s\n", s->max_channel+2, sample_message);
00389         return -1;
00390     }
00391 
00392     if (s->min_channel > s->max_channel) {
00393         av_log(m->avctx, AV_LOG_ERROR,
00394                "Substream min channel cannot be greater than max channel.\n");
00395         return -1;
00396     }
00397 
00398     if (m->avctx->request_channels > 0
00399         && s->max_channel + 1 >= m->avctx->request_channels
00400         && substr < m->max_decoded_substream) {
00401         av_log(m->avctx, AV_LOG_DEBUG,
00402                "Extracting %d channel downmix from substream %d. "
00403                "Further substreams will be skipped.\n",
00404                s->max_channel + 1, substr);
00405         m->max_decoded_substream = substr;
00406     }
00407 
00408     s->noise_shift   = get_bits(gbp,  4);
00409     s->noisegen_seed = get_bits(gbp, 23);
00410 
00411     skip_bits(gbp, 19);
00412 
00413     s->data_check_present = get_bits1(gbp);
00414     lossless_check = get_bits(gbp, 8);
00415     if (substr == m->max_decoded_substream
00416         && s->lossless_check_data != 0xffffffff) {
00417         tmp = xor_32_to_8(s->lossless_check_data);
00418         if (tmp != lossless_check)
00419             av_log(m->avctx, AV_LOG_WARNING,
00420                    "Lossless check failed - expected %02x, calculated %02x.\n",
00421                    lossless_check, tmp);
00422     }
00423 
00424     skip_bits(gbp, 16);
00425 
00426     memset(s->ch_assign, 0, sizeof(s->ch_assign));
00427 
00428     for (ch = 0; ch <= s->max_matrix_channel; ch++) {
00429         int ch_assign = get_bits(gbp, 6);
00430         if (ch_assign > s->max_matrix_channel) {
00431             av_log(m->avctx, AV_LOG_ERROR,
00432                    "Assignment of matrix channel %d to invalid output channel %d. %s\n",
00433                    ch, ch_assign, sample_message);
00434             return -1;
00435         }
00436         s->ch_assign[ch_assign] = ch;
00437     }
00438 
00439     checksum = ff_mlp_restart_checksum(buf, get_bits_count(gbp) - start_count);
00440 
00441     if (checksum != get_bits(gbp, 8))
00442         av_log(m->avctx, AV_LOG_ERROR, "restart header checksum error\n");
00443 
00444     /* Set default decoding parameters. */
00445     s->param_presence_flags   = 0xff;
00446     s->num_primitive_matrices = 0;
00447     s->blocksize              = 8;
00448     s->lossless_check_data    = 0;
00449 
00450     memset(s->output_shift   , 0, sizeof(s->output_shift   ));
00451     memset(s->quant_step_size, 0, sizeof(s->quant_step_size));
00452 
00453     for (ch = s->min_channel; ch <= s->max_channel; ch++) {
00454         ChannelParams *cp = &s->channel_params[ch];
00455         cp->filter_params[FIR].order = 0;
00456         cp->filter_params[IIR].order = 0;
00457         cp->filter_params[FIR].shift = 0;
00458         cp->filter_params[IIR].shift = 0;
00459 
00460         /* Default audio coding is 24-bit raw PCM. */
00461         cp->huff_offset      = 0;
00462         cp->sign_huff_offset = (-1) << 23;
00463         cp->codebook         = 0;
00464         cp->huff_lsbs        = 24;
00465     }
00466 
00467     if (substr == m->max_decoded_substream)
00468         m->avctx->channels = s->max_matrix_channel + 1;
00469 
00470     return 0;
00471 }
00472 
00475 static int read_filter_params(MLPDecodeContext *m, GetBitContext *gbp,
00476                               unsigned int substr, unsigned int channel,
00477                               unsigned int filter)
00478 {
00479     SubStream *s = &m->substream[substr];
00480     FilterParams *fp = &s->channel_params[channel].filter_params[filter];
00481     const int max_order = filter ? MAX_IIR_ORDER : MAX_FIR_ORDER;
00482     const char fchar = filter ? 'I' : 'F';
00483     int i, order;
00484 
00485     // Filter is 0 for FIR, 1 for IIR.
00486     assert(filter < 2);
00487 
00488     if (m->filter_changed[channel][filter]++ > 1) {
00489         av_log(m->avctx, AV_LOG_ERROR, "Filters may change only once per access unit.\n");
00490         return -1;
00491     }
00492 
00493     order = get_bits(gbp, 4);
00494     if (order > max_order) {
00495         av_log(m->avctx, AV_LOG_ERROR,
00496                "%cIR filter order %d is greater than maximum %d.\n",
00497                fchar, order, max_order);
00498         return -1;
00499     }
00500     fp->order = order;
00501 
00502     if (order > 0) {
00503         int32_t *fcoeff = s->channel_params[channel].coeff[filter];
00504         int coeff_bits, coeff_shift;
00505 
00506         fp->shift = get_bits(gbp, 4);
00507 
00508         coeff_bits  = get_bits(gbp, 5);
00509         coeff_shift = get_bits(gbp, 3);
00510         if (coeff_bits < 1 || coeff_bits > 16) {
00511             av_log(m->avctx, AV_LOG_ERROR,
00512                    "%cIR filter coeff_bits must be between 1 and 16.\n",
00513                    fchar);
00514             return -1;
00515         }
00516         if (coeff_bits + coeff_shift > 16) {
00517             av_log(m->avctx, AV_LOG_ERROR,
00518                    "Sum of coeff_bits and coeff_shift for %cIR filter must be 16 or less.\n",
00519                    fchar);
00520             return -1;
00521         }
00522 
00523         for (i = 0; i < order; i++)
00524             fcoeff[i] = get_sbits(gbp, coeff_bits) << coeff_shift;
00525 
00526         if (get_bits1(gbp)) {
00527             int state_bits, state_shift;
00528 
00529             if (filter == FIR) {
00530                 av_log(m->avctx, AV_LOG_ERROR,
00531                        "FIR filter has state data specified.\n");
00532                 return -1;
00533             }
00534 
00535             state_bits  = get_bits(gbp, 4);
00536             state_shift = get_bits(gbp, 4);
00537 
00538             /* TODO: Check validity of state data. */
00539 
00540             for (i = 0; i < order; i++)
00541                 fp->state[i] = get_sbits(gbp, state_bits) << state_shift;
00542         }
00543     }
00544 
00545     return 0;
00546 }
00547 
00550 static int read_matrix_params(MLPDecodeContext *m, unsigned int substr, GetBitContext *gbp)
00551 {
00552     SubStream *s = &m->substream[substr];
00553     unsigned int mat, ch;
00554     const int max_primitive_matrices = m->avctx->codec_id == CODEC_ID_MLP
00555                                      ? MAX_MATRICES_MLP
00556                                      : MAX_MATRICES_TRUEHD;
00557 
00558     if (m->matrix_changed++ > 1) {
00559         av_log(m->avctx, AV_LOG_ERROR, "Matrices may change only once per access unit.\n");
00560         return -1;
00561     }
00562 
00563     s->num_primitive_matrices = get_bits(gbp, 4);
00564 
00565     if (s->num_primitive_matrices > max_primitive_matrices) {
00566         av_log(m->avctx, AV_LOG_ERROR,
00567                "Number of primitive matrices cannot be greater than %d.\n",
00568                max_primitive_matrices);
00569         return -1;
00570     }
00571 
00572     for (mat = 0; mat < s->num_primitive_matrices; mat++) {
00573         int frac_bits, max_chan;
00574         s->matrix_out_ch[mat] = get_bits(gbp, 4);
00575         frac_bits             = get_bits(gbp, 4);
00576         s->lsb_bypass   [mat] = get_bits1(gbp);
00577 
00578         if (s->matrix_out_ch[mat] > s->max_matrix_channel) {
00579             av_log(m->avctx, AV_LOG_ERROR,
00580                     "Invalid channel %d specified as output from matrix.\n",
00581                     s->matrix_out_ch[mat]);
00582             return -1;
00583         }
00584         if (frac_bits > 14) {
00585             av_log(m->avctx, AV_LOG_ERROR,
00586                     "Too many fractional bits specified.\n");
00587             return -1;
00588         }
00589 
00590         max_chan = s->max_matrix_channel;
00591         if (!s->noise_type)
00592             max_chan+=2;
00593 
00594         for (ch = 0; ch <= max_chan; ch++) {
00595             int coeff_val = 0;
00596             if (get_bits1(gbp))
00597                 coeff_val = get_sbits(gbp, frac_bits + 2);
00598 
00599             s->matrix_coeff[mat][ch] = coeff_val << (14 - frac_bits);
00600         }
00601 
00602         if (s->noise_type)
00603             s->matrix_noise_shift[mat] = get_bits(gbp, 4);
00604         else
00605             s->matrix_noise_shift[mat] = 0;
00606     }
00607 
00608     return 0;
00609 }
00610 
00613 static int read_channel_params(MLPDecodeContext *m, unsigned int substr,
00614                                GetBitContext *gbp, unsigned int ch)
00615 {
00616     SubStream *s = &m->substream[substr];
00617     ChannelParams *cp = &s->channel_params[ch];
00618     FilterParams *fir = &cp->filter_params[FIR];
00619     FilterParams *iir = &cp->filter_params[IIR];
00620 
00621     if (s->param_presence_flags & PARAM_FIR)
00622         if (get_bits1(gbp))
00623             if (read_filter_params(m, gbp, substr, ch, FIR) < 0)
00624                 return -1;
00625 
00626     if (s->param_presence_flags & PARAM_IIR)
00627         if (get_bits1(gbp))
00628             if (read_filter_params(m, gbp, substr, ch, IIR) < 0)
00629                 return -1;
00630 
00631     if (fir->order + iir->order > 8) {
00632         av_log(m->avctx, AV_LOG_ERROR, "Total filter orders too high.\n");
00633         return -1;
00634     }
00635 
00636     if (fir->order && iir->order &&
00637         fir->shift != iir->shift) {
00638         av_log(m->avctx, AV_LOG_ERROR,
00639                 "FIR and IIR filters must use the same precision.\n");
00640         return -1;
00641     }
00642     /* The FIR and IIR filters must have the same precision.
00643      * To simplify the filtering code, only the precision of the
00644      * FIR filter is considered. If only the IIR filter is employed,
00645      * the FIR filter precision is set to that of the IIR filter, so
00646      * that the filtering code can use it. */
00647     if (!fir->order && iir->order)
00648         fir->shift = iir->shift;
00649 
00650     if (s->param_presence_flags & PARAM_HUFFOFFSET)
00651         if (get_bits1(gbp))
00652             cp->huff_offset = get_sbits(gbp, 15);
00653 
00654     cp->codebook  = get_bits(gbp, 2);
00655     cp->huff_lsbs = get_bits(gbp, 5);
00656 
00657     if (cp->huff_lsbs > 24) {
00658         av_log(m->avctx, AV_LOG_ERROR, "Invalid huff_lsbs.\n");
00659         return -1;
00660     }
00661 
00662     cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
00663 
00664     return 0;
00665 }
00666 
00670 static int read_decoding_params(MLPDecodeContext *m, GetBitContext *gbp,
00671                                 unsigned int substr)
00672 {
00673     SubStream *s = &m->substream[substr];
00674     unsigned int ch;
00675 
00676     if (s->param_presence_flags & PARAM_PRESENCE)
00677         if (get_bits1(gbp))
00678             s->param_presence_flags = get_bits(gbp, 8);
00679 
00680     if (s->param_presence_flags & PARAM_BLOCKSIZE)
00681         if (get_bits1(gbp)) {
00682             s->blocksize = get_bits(gbp, 9);
00683             if (s->blocksize < 8 || s->blocksize > m->access_unit_size) {
00684                 av_log(m->avctx, AV_LOG_ERROR, "Invalid blocksize.");
00685                 s->blocksize = 0;
00686                 return -1;
00687             }
00688         }
00689 
00690     if (s->param_presence_flags & PARAM_MATRIX)
00691         if (get_bits1(gbp))
00692             if (read_matrix_params(m, substr, gbp) < 0)
00693                 return -1;
00694 
00695     if (s->param_presence_flags & PARAM_OUTSHIFT)
00696         if (get_bits1(gbp))
00697             for (ch = 0; ch <= s->max_matrix_channel; ch++)
00698                 s->output_shift[ch] = get_sbits(gbp, 4);
00699 
00700     if (s->param_presence_flags & PARAM_QUANTSTEP)
00701         if (get_bits1(gbp))
00702             for (ch = 0; ch <= s->max_channel; ch++) {
00703                 ChannelParams *cp = &s->channel_params[ch];
00704 
00705                 s->quant_step_size[ch] = get_bits(gbp, 4);
00706 
00707                 cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
00708             }
00709 
00710     for (ch = s->min_channel; ch <= s->max_channel; ch++)
00711         if (get_bits1(gbp))
00712             if (read_channel_params(m, substr, gbp, ch) < 0)
00713                 return -1;
00714 
00715     return 0;
00716 }
00717 
00718 #define MSB_MASK(bits)  (-1u << bits)
00719 
00723 static void filter_channel(MLPDecodeContext *m, unsigned int substr,
00724                            unsigned int channel)
00725 {
00726     SubStream *s = &m->substream[substr];
00727     const int32_t *fircoeff = s->channel_params[channel].coeff[FIR];
00728     int32_t state_buffer[NUM_FILTERS][MAX_BLOCKSIZE + MAX_FIR_ORDER];
00729     int32_t *firbuf = state_buffer[FIR] + MAX_BLOCKSIZE;
00730     int32_t *iirbuf = state_buffer[IIR] + MAX_BLOCKSIZE;
00731     FilterParams *fir = &s->channel_params[channel].filter_params[FIR];
00732     FilterParams *iir = &s->channel_params[channel].filter_params[IIR];
00733     unsigned int filter_shift = fir->shift;
00734     int32_t mask = MSB_MASK(s->quant_step_size[channel]);
00735 
00736     memcpy(firbuf, fir->state, MAX_FIR_ORDER * sizeof(int32_t));
00737     memcpy(iirbuf, iir->state, MAX_IIR_ORDER * sizeof(int32_t));
00738 
00739     m->dsp.mlp_filter_channel(firbuf, fircoeff,
00740                               fir->order, iir->order,
00741                               filter_shift, mask, s->blocksize,
00742                               &m->sample_buffer[s->blockpos][channel]);
00743 
00744     memcpy(fir->state, firbuf - s->blocksize, MAX_FIR_ORDER * sizeof(int32_t));
00745     memcpy(iir->state, iirbuf - s->blocksize, MAX_IIR_ORDER * sizeof(int32_t));
00746 }
00747 
00750 static int read_block_data(MLPDecodeContext *m, GetBitContext *gbp,
00751                            unsigned int substr)
00752 {
00753     SubStream *s = &m->substream[substr];
00754     unsigned int i, ch, expected_stream_pos = 0;
00755 
00756     if (s->data_check_present) {
00757         expected_stream_pos  = get_bits_count(gbp);
00758         expected_stream_pos += get_bits(gbp, 16);
00759         av_log(m->avctx, AV_LOG_WARNING, "This file contains some features "
00760                "we have not tested yet. %s\n", sample_message);
00761     }
00762 
00763     if (s->blockpos + s->blocksize > m->access_unit_size) {
00764         av_log(m->avctx, AV_LOG_ERROR, "too many audio samples in frame\n");
00765         return -1;
00766     }
00767 
00768     memset(&m->bypassed_lsbs[s->blockpos][0], 0,
00769            s->blocksize * sizeof(m->bypassed_lsbs[0]));
00770 
00771     for (i = 0; i < s->blocksize; i++)
00772         if (read_huff_channels(m, gbp, substr, i) < 0)
00773             return -1;
00774 
00775     for (ch = s->min_channel; ch <= s->max_channel; ch++)
00776         filter_channel(m, substr, ch);
00777 
00778     s->blockpos += s->blocksize;
00779 
00780     if (s->data_check_present) {
00781         if (get_bits_count(gbp) != expected_stream_pos)
00782             av_log(m->avctx, AV_LOG_ERROR, "block data length mismatch\n");
00783         skip_bits(gbp, 8);
00784     }
00785 
00786     return 0;
00787 }
00788 
00791 static const int8_t noise_table[256] = {
00792      30,  51,  22,  54,   3,   7,  -4,  38,  14,  55,  46,  81,  22,  58,  -3,   2,
00793      52,  31,  -7,  51,  15,  44,  74,  30,  85, -17,  10,  33,  18,  80,  28,  62,
00794      10,  32,  23,  69,  72,  26,  35,  17,  73,  60,   8,  56,   2,   6,  -2,  -5,
00795      51,   4,  11,  50,  66,  76,  21,  44,  33,  47,   1,  26,  64,  48,  57,  40,
00796      38,  16, -10, -28,  92,  22, -18,  29, -10,   5, -13,  49,  19,  24,  70,  34,
00797      61,  48,  30,  14,  -6,  25,  58,  33,  42,  60,  67,  17,  54,  17,  22,  30,
00798      67,  44,  -9,  50, -11,  43,  40,  32,  59,  82,  13,  49, -14,  55,  60,  36,
00799      48,  49,  31,  47,  15,  12,   4,  65,   1,  23,  29,  39,  45,  -2,  84,  69,
00800       0,  72,  37,  57,  27,  41, -15, -16,  35,  31,  14,  61,  24,   0,  27,  24,
00801      16,  41,  55,  34,  53,   9,  56,  12,  25,  29,  53,   5,  20, -20,  -8,  20,
00802      13,  28,  -3,  78,  38,  16,  11,  62,  46,  29,  21,  24,  46,  65,  43, -23,
00803      89,  18,  74,  21,  38, -12,  19,  12, -19,   8,  15,  33,   4,  57,   9,  -8,
00804      36,  35,  26,  28,   7,  83,  63,  79,  75,  11,   3,  87,  37,  47,  34,  40,
00805      39,  19,  20,  42,  27,  34,  39,  77,  13,  42,  59,  64,  45,  -1,  32,  37,
00806      45,  -5,  53,  -6,   7,  36,  50,  23,   6,  32,   9, -21,  18,  71,  27,  52,
00807     -25,  31,  35,  42,  -1,  68,  63,  52,  26,  43,  66,  37,  41,  25,  40,  70,
00808 };
00809 
00820 static void generate_2_noise_channels(MLPDecodeContext *m, unsigned int substr)
00821 {
00822     SubStream *s = &m->substream[substr];
00823     unsigned int i;
00824     uint32_t seed = s->noisegen_seed;
00825     unsigned int maxchan = s->max_matrix_channel;
00826 
00827     for (i = 0; i < s->blockpos; i++) {
00828         uint16_t seed_shr7 = seed >> 7;
00829         m->sample_buffer[i][maxchan+1] = ((int8_t)(seed >> 15)) << s->noise_shift;
00830         m->sample_buffer[i][maxchan+2] = ((int8_t) seed_shr7)   << s->noise_shift;
00831 
00832         seed = (seed << 16) ^ seed_shr7 ^ (seed_shr7 << 5);
00833     }
00834 
00835     s->noisegen_seed = seed;
00836 }
00837 
00840 static void fill_noise_buffer(MLPDecodeContext *m, unsigned int substr)
00841 {
00842     SubStream *s = &m->substream[substr];
00843     unsigned int i;
00844     uint32_t seed = s->noisegen_seed;
00845 
00846     for (i = 0; i < m->access_unit_size_pow2; i++) {
00847         uint8_t seed_shr15 = seed >> 15;
00848         m->noise_buffer[i] = noise_table[seed_shr15];
00849         seed = (seed << 8) ^ seed_shr15 ^ (seed_shr15 << 5);
00850     }
00851 
00852     s->noisegen_seed = seed;
00853 }
00854 
00855 
00859 static void rematrix_channels(MLPDecodeContext *m, unsigned int substr)
00860 {
00861     SubStream *s = &m->substream[substr];
00862     unsigned int mat, src_ch, i;
00863     unsigned int maxchan;
00864 
00865     maxchan = s->max_matrix_channel;
00866     if (!s->noise_type) {
00867         generate_2_noise_channels(m, substr);
00868         maxchan += 2;
00869     } else {
00870         fill_noise_buffer(m, substr);
00871     }
00872 
00873     for (mat = 0; mat < s->num_primitive_matrices; mat++) {
00874         int matrix_noise_shift = s->matrix_noise_shift[mat];
00875         unsigned int dest_ch = s->matrix_out_ch[mat];
00876         int32_t mask = MSB_MASK(s->quant_step_size[dest_ch]);
00877         int32_t *coeffs = s->matrix_coeff[mat];
00878         int index  = s->num_primitive_matrices - mat;
00879         int index2 = 2 * index + 1;
00880 
00881         /* TODO: DSPContext? */
00882 
00883         for (i = 0; i < s->blockpos; i++) {
00884             int32_t bypassed_lsb = m->bypassed_lsbs[i][mat];
00885             int32_t *samples = m->sample_buffer[i];
00886             int64_t accum = 0;
00887 
00888             for (src_ch = 0; src_ch <= maxchan; src_ch++)
00889                 accum += (int64_t) samples[src_ch] * coeffs[src_ch];
00890 
00891             if (matrix_noise_shift) {
00892                 index &= m->access_unit_size_pow2 - 1;
00893                 accum += m->noise_buffer[index] << (matrix_noise_shift + 7);
00894                 index += index2;
00895             }
00896 
00897             samples[dest_ch] = ((accum >> 14) & mask) + bypassed_lsb;
00898         }
00899     }
00900 }
00901 
00904 static int output_data_internal(MLPDecodeContext *m, unsigned int substr,
00905                                 uint8_t *data, unsigned int *data_size, int is32)
00906 {
00907     SubStream *s = &m->substream[substr];
00908     unsigned int i, out_ch = 0;
00909     int32_t *data_32 = (int32_t*) data;
00910     int16_t *data_16 = (int16_t*) data;
00911 
00912     if (*data_size < (s->max_channel + 1) * s->blockpos * (is32 ? 4 : 2))
00913         return -1;
00914 
00915     for (i = 0; i < s->blockpos; i++) {
00916         for (out_ch = 0; out_ch <= s->max_matrix_channel; out_ch++) {
00917             int mat_ch = s->ch_assign[out_ch];
00918             int32_t sample = m->sample_buffer[i][mat_ch]
00919                           << s->output_shift[mat_ch];
00920             s->lossless_check_data ^= (sample & 0xffffff) << mat_ch;
00921             if (is32) *data_32++ = sample << 8;
00922             else      *data_16++ = sample >> 8;
00923         }
00924     }
00925 
00926     *data_size = i * out_ch * (is32 ? 4 : 2);
00927 
00928     return 0;
00929 }
00930 
00931 static int output_data(MLPDecodeContext *m, unsigned int substr,
00932                        uint8_t *data, unsigned int *data_size)
00933 {
00934     if (m->avctx->sample_fmt == SAMPLE_FMT_S32)
00935         return output_data_internal(m, substr, data, data_size, 1);
00936     else
00937         return output_data_internal(m, substr, data, data_size, 0);
00938 }
00939 
00940 
00945 static int read_access_unit(AVCodecContext *avctx, void* data, int *data_size,
00946                             AVPacket *avpkt)
00947 {
00948     const uint8_t *buf = avpkt->data;
00949     int buf_size = avpkt->size;
00950     MLPDecodeContext *m = avctx->priv_data;
00951     GetBitContext gb;
00952     unsigned int length, substr;
00953     unsigned int substream_start;
00954     unsigned int header_size = 4;
00955     unsigned int substr_header_size = 0;
00956     uint8_t substream_parity_present[MAX_SUBSTREAMS];
00957     uint16_t substream_data_len[MAX_SUBSTREAMS];
00958     uint8_t parity_bits;
00959 
00960     if (buf_size < 4)
00961         return 0;
00962 
00963     length = (AV_RB16(buf) & 0xfff) * 2;
00964 
00965     if (length < 4 || length > buf_size)
00966         return -1;
00967 
00968     init_get_bits(&gb, (buf + 4), (length - 4) * 8);
00969 
00970     m->is_major_sync_unit = 0;
00971     if (show_bits_long(&gb, 31) == (0xf8726fba >> 1)) {
00972         if (read_major_sync(m, &gb) < 0)
00973             goto error;
00974         m->is_major_sync_unit = 1;
00975         header_size += 28;
00976     }
00977 
00978     if (!m->params_valid) {
00979         av_log(m->avctx, AV_LOG_WARNING,
00980                "Stream parameters not seen; skipping frame.\n");
00981         *data_size = 0;
00982         return length;
00983     }
00984 
00985     substream_start = 0;
00986 
00987     for (substr = 0; substr < m->num_substreams; substr++) {
00988         int extraword_present, checkdata_present, end, nonrestart_substr;
00989 
00990         extraword_present = get_bits1(&gb);
00991         nonrestart_substr = get_bits1(&gb);
00992         checkdata_present = get_bits1(&gb);
00993         skip_bits1(&gb);
00994 
00995         end = get_bits(&gb, 12) * 2;
00996 
00997         substr_header_size += 2;
00998 
00999         if (extraword_present) {
01000             if (m->avctx->codec_id == CODEC_ID_MLP) {
01001                 av_log(m->avctx, AV_LOG_ERROR, "There must be no extraword for MLP.\n");
01002                 goto error;
01003             }
01004             skip_bits(&gb, 16);
01005             substr_header_size += 2;
01006         }
01007 
01008         if (!(nonrestart_substr ^ m->is_major_sync_unit)) {
01009             av_log(m->avctx, AV_LOG_ERROR, "Invalid nonrestart_substr.\n");
01010             goto error;
01011         }
01012 
01013         if (end + header_size + substr_header_size > length) {
01014             av_log(m->avctx, AV_LOG_ERROR,
01015                    "Indicated length of substream %d data goes off end of "
01016                    "packet.\n", substr);
01017             end = length - header_size - substr_header_size;
01018         }
01019 
01020         if (end < substream_start) {
01021             av_log(avctx, AV_LOG_ERROR,
01022                    "Indicated end offset of substream %d data "
01023                    "is smaller than calculated start offset.\n",
01024                    substr);
01025             goto error;
01026         }
01027 
01028         if (substr > m->max_decoded_substream)
01029             continue;
01030 
01031         substream_parity_present[substr] = checkdata_present;
01032         substream_data_len[substr] = end - substream_start;
01033         substream_start = end;
01034     }
01035 
01036     parity_bits  = ff_mlp_calculate_parity(buf, 4);
01037     parity_bits ^= ff_mlp_calculate_parity(buf + header_size, substr_header_size);
01038 
01039     if ((((parity_bits >> 4) ^ parity_bits) & 0xF) != 0xF) {
01040         av_log(avctx, AV_LOG_ERROR, "Parity check failed.\n");
01041         goto error;
01042     }
01043 
01044     buf += header_size + substr_header_size;
01045 
01046     for (substr = 0; substr <= m->max_decoded_substream; substr++) {
01047         SubStream *s = &m->substream[substr];
01048         init_get_bits(&gb, buf, substream_data_len[substr] * 8);
01049 
01050         m->matrix_changed = 0;
01051         memset(m->filter_changed, 0, sizeof(m->filter_changed));
01052 
01053         s->blockpos = 0;
01054         do {
01055             if (get_bits1(&gb)) {
01056                 if (get_bits1(&gb)) {
01057                     /* A restart header should be present. */
01058                     if (read_restart_header(m, &gb, buf, substr) < 0)
01059                         goto next_substr;
01060                     s->restart_seen = 1;
01061                 }
01062 
01063                 if (!s->restart_seen)
01064                     goto next_substr;
01065                 if (read_decoding_params(m, &gb, substr) < 0)
01066                     goto next_substr;
01067             }
01068 
01069             if (!s->restart_seen)
01070                 goto next_substr;
01071 
01072             if (read_block_data(m, &gb, substr) < 0)
01073                 return -1;
01074 
01075             if (get_bits_count(&gb) >= substream_data_len[substr] * 8)
01076                 goto substream_length_mismatch;
01077 
01078         } while (!get_bits1(&gb));
01079 
01080         skip_bits(&gb, (-get_bits_count(&gb)) & 15);
01081 
01082         if (substream_data_len[substr] * 8 - get_bits_count(&gb) >= 32) {
01083             int shorten_by;
01084 
01085             if (get_bits(&gb, 16) != 0xD234)
01086                 return -1;
01087 
01088             shorten_by = get_bits(&gb, 16);
01089             if      (m->avctx->codec_id == CODEC_ID_TRUEHD && shorten_by  & 0x2000)
01090                 s->blockpos -= FFMIN(shorten_by & 0x1FFF, s->blockpos);
01091             else if (m->avctx->codec_id == CODEC_ID_MLP    && shorten_by != 0xD234)
01092                 return -1;
01093 
01094             if (substr == m->max_decoded_substream)
01095                 av_log(m->avctx, AV_LOG_INFO, "End of stream indicated.\n");
01096         }
01097 
01098         if (substream_parity_present[substr]) {
01099             uint8_t parity, checksum;
01100 
01101             if (substream_data_len[substr] * 8 - get_bits_count(&gb) != 16)
01102                 goto substream_length_mismatch;
01103 
01104             parity   = ff_mlp_calculate_parity(buf, substream_data_len[substr] - 2);
01105             checksum = ff_mlp_checksum8       (buf, substream_data_len[substr] - 2);
01106 
01107             if ((get_bits(&gb, 8) ^ parity) != 0xa9    )
01108                 av_log(m->avctx, AV_LOG_ERROR, "Substream %d parity check failed.\n", substr);
01109             if ( get_bits(&gb, 8)           != checksum)
01110                 av_log(m->avctx, AV_LOG_ERROR, "Substream %d checksum failed.\n"    , substr);
01111         }
01112 
01113         if (substream_data_len[substr] * 8 != get_bits_count(&gb))
01114             goto substream_length_mismatch;
01115 
01116 next_substr:
01117         if (!s->restart_seen)
01118             av_log(m->avctx, AV_LOG_ERROR,
01119                    "No restart header present in substream %d.\n", substr);
01120 
01121         buf += substream_data_len[substr];
01122     }
01123 
01124     rematrix_channels(m, m->max_decoded_substream);
01125 
01126     if (output_data(m, m->max_decoded_substream, data, data_size) < 0)
01127         return -1;
01128 
01129     return length;
01130 
01131 substream_length_mismatch:
01132     av_log(m->avctx, AV_LOG_ERROR, "substream %d length mismatch\n", substr);
01133     return -1;
01134 
01135 error:
01136     m->params_valid = 0;
01137     return -1;
01138 }
01139 
01140 AVCodec mlp_decoder = {
01141     "mlp",
01142     AVMEDIA_TYPE_AUDIO,
01143     CODEC_ID_MLP,
01144     sizeof(MLPDecodeContext),
01145     mlp_decode_init,
01146     NULL,
01147     NULL,
01148     read_access_unit,
01149     .long_name = NULL_IF_CONFIG_SMALL("MLP (Meridian Lossless Packing)"),
01150 };
01151 
01152 #if CONFIG_TRUEHD_DECODER
01153 AVCodec truehd_decoder = {
01154     "truehd",
01155     AVMEDIA_TYPE_AUDIO,
01156     CODEC_ID_TRUEHD,
01157     sizeof(MLPDecodeContext),
01158     mlp_decode_init,
01159     NULL,
01160     NULL,
01161     read_access_unit,
01162     .long_name = NULL_IF_CONFIG_SMALL("TrueHD"),
01163 };
01164 #endif /* CONFIG_TRUEHD_DECODER */

Generated on Fri Sep 16 2011 17:17:39 for FFmpeg by  doxygen 1.7.1