Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | RSS feed

  1. /*
  2.  * Musepack SV7 decoder
  3.  * Copyright (c) 2006 Konstantin Shishkov
  4.  *
  5.  * This file is part of FFmpeg.
  6.  *
  7.  * FFmpeg is free software; you can redistribute it and/or
  8.  * modify it under the terms of the GNU Lesser General Public
  9.  * License as published by the Free Software Foundation; either
  10.  * version 2.1 of the License, or (at your option) any later version.
  11.  *
  12.  * FFmpeg is distributed in the hope that it will be useful,
  13.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15.  * Lesser General Public License for more details.
  16.  *
  17.  * You should have received a copy of the GNU Lesser General Public
  18.  * License along with FFmpeg; if not, write to the Free Software
  19.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20.  */
  21.  
  22. /**
  23.  * @file
  24.  * MPEG Audio Layer 1/2 -like codec with frames of 1152 samples
  25.  * divided into 32 subbands.
  26.  */
  27.  
  28. #include "libavutil/channel_layout.h"
  29. #include "libavutil/internal.h"
  30. #include "libavutil/lfg.h"
  31. #include "avcodec.h"
  32. #include "get_bits.h"
  33. #include "dsputil.h"
  34. #include "internal.h"
  35. #include "mpegaudiodsp.h"
  36.  
  37. #include "mpc.h"
  38. #include "mpc7data.h"
  39.  
  40. static VLC scfi_vlc, dscf_vlc, hdr_vlc, quant_vlc[MPC7_QUANT_VLC_TABLES][2];
  41.  
  42. static const uint16_t quant_offsets[MPC7_QUANT_VLC_TABLES*2 + 1] =
  43. {
  44.        0, 512, 1024, 1536, 2052, 2564, 3076, 3588, 4100, 4612, 5124,
  45.        5636, 6164, 6676, 7224
  46. };
  47.  
  48.  
  49. static av_cold int mpc7_decode_init(AVCodecContext * avctx)
  50. {
  51.     int i, j;
  52.     MPCContext *c = avctx->priv_data;
  53.     GetBitContext gb;
  54.     LOCAL_ALIGNED_16(uint8_t, buf, [16]);
  55.     static int vlc_initialized = 0;
  56.  
  57.     static VLC_TYPE scfi_table[1 << MPC7_SCFI_BITS][2];
  58.     static VLC_TYPE dscf_table[1 << MPC7_DSCF_BITS][2];
  59.     static VLC_TYPE hdr_table[1 << MPC7_HDR_BITS][2];
  60.     static VLC_TYPE quant_tables[7224][2];
  61.  
  62.     /* Musepack SV7 is always stereo */
  63.     if (avctx->channels != 2) {
  64.         avpriv_request_sample(avctx, "%d channels", avctx->channels);
  65.         return AVERROR_PATCHWELCOME;
  66.     }
  67.  
  68.     if(avctx->extradata_size < 16){
  69.         av_log(avctx, AV_LOG_ERROR, "Too small extradata size (%i)!\n", avctx->extradata_size);
  70.         return -1;
  71.     }
  72.     memset(c->oldDSCF, 0, sizeof(c->oldDSCF));
  73.     av_lfg_init(&c->rnd, 0xDEADBEEF);
  74.     ff_dsputil_init(&c->dsp, avctx);
  75.     ff_mpadsp_init(&c->mpadsp);
  76.     c->dsp.bswap_buf((uint32_t*)buf, (const uint32_t*)avctx->extradata, 4);
  77.     ff_mpc_init();
  78.     init_get_bits(&gb, buf, 128);
  79.  
  80.     c->IS = get_bits1(&gb);
  81.     c->MSS = get_bits1(&gb);
  82.     c->maxbands = get_bits(&gb, 6);
  83.     if(c->maxbands >= BANDS){
  84.         av_log(avctx, AV_LOG_ERROR, "Too many bands: %i\n", c->maxbands);
  85.         return -1;
  86.     }
  87.     skip_bits_long(&gb, 88);
  88.     c->gapless = get_bits1(&gb);
  89.     c->lastframelen = get_bits(&gb, 11);
  90.     av_log(avctx, AV_LOG_DEBUG, "IS: %d, MSS: %d, TG: %d, LFL: %d, bands: %d\n",
  91.             c->IS, c->MSS, c->gapless, c->lastframelen, c->maxbands);
  92.     c->frames_to_skip = 0;
  93.  
  94.     avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
  95.     avctx->channel_layout = AV_CH_LAYOUT_STEREO;
  96.  
  97.     if(vlc_initialized) return 0;
  98.     av_log(avctx, AV_LOG_DEBUG, "Initing VLC\n");
  99.     scfi_vlc.table = scfi_table;
  100.     scfi_vlc.table_allocated = 1 << MPC7_SCFI_BITS;
  101.     if(init_vlc(&scfi_vlc, MPC7_SCFI_BITS, MPC7_SCFI_SIZE,
  102.                 &mpc7_scfi[1], 2, 1,
  103.                 &mpc7_scfi[0], 2, 1, INIT_VLC_USE_NEW_STATIC)){
  104.         av_log(avctx, AV_LOG_ERROR, "Cannot init SCFI VLC\n");
  105.         return -1;
  106.     }
  107.     dscf_vlc.table = dscf_table;
  108.     dscf_vlc.table_allocated = 1 << MPC7_DSCF_BITS;
  109.     if(init_vlc(&dscf_vlc, MPC7_DSCF_BITS, MPC7_DSCF_SIZE,
  110.                 &mpc7_dscf[1], 2, 1,
  111.                 &mpc7_dscf[0], 2, 1, INIT_VLC_USE_NEW_STATIC)){
  112.         av_log(avctx, AV_LOG_ERROR, "Cannot init DSCF VLC\n");
  113.         return -1;
  114.     }
  115.     hdr_vlc.table = hdr_table;
  116.     hdr_vlc.table_allocated = 1 << MPC7_HDR_BITS;
  117.     if(init_vlc(&hdr_vlc, MPC7_HDR_BITS, MPC7_HDR_SIZE,
  118.                 &mpc7_hdr[1], 2, 1,
  119.                 &mpc7_hdr[0], 2, 1, INIT_VLC_USE_NEW_STATIC)){
  120.         av_log(avctx, AV_LOG_ERROR, "Cannot init HDR VLC\n");
  121.         return -1;
  122.     }
  123.     for(i = 0; i < MPC7_QUANT_VLC_TABLES; i++){
  124.         for(j = 0; j < 2; j++){
  125.             quant_vlc[i][j].table = &quant_tables[quant_offsets[i*2 + j]];
  126.             quant_vlc[i][j].table_allocated = quant_offsets[i*2 + j + 1] - quant_offsets[i*2 + j];
  127.             if(init_vlc(&quant_vlc[i][j], 9, mpc7_quant_vlc_sizes[i],
  128.                         &mpc7_quant_vlc[i][j][1], 4, 2,
  129.                         &mpc7_quant_vlc[i][j][0], 4, 2, INIT_VLC_USE_NEW_STATIC)){
  130.                 av_log(avctx, AV_LOG_ERROR, "Cannot init QUANT VLC %i,%i\n",i,j);
  131.                 return -1;
  132.             }
  133.         }
  134.     }
  135.     vlc_initialized = 1;
  136.  
  137.     return 0;
  138. }
  139.  
  140. /**
  141.  * Fill samples for given subband
  142.  */
  143. static inline void idx_to_quant(MPCContext *c, GetBitContext *gb, int idx, int *dst)
  144. {
  145.     int i, i1, t;
  146.     switch(idx){
  147.     case -1:
  148.         for(i = 0; i < SAMPLES_PER_BAND; i++){
  149.             *dst++ = (av_lfg_get(&c->rnd) & 0x3FC) - 510;
  150.         }
  151.         break;
  152.     case 1:
  153.         i1 = get_bits1(gb);
  154.         for(i = 0; i < SAMPLES_PER_BAND/3; i++){
  155.             t = get_vlc2(gb, quant_vlc[0][i1].table, 9, 2);
  156.             *dst++ = mpc7_idx30[t];
  157.             *dst++ = mpc7_idx31[t];
  158.             *dst++ = mpc7_idx32[t];
  159.         }
  160.         break;
  161.     case 2:
  162.         i1 = get_bits1(gb);
  163.         for(i = 0; i < SAMPLES_PER_BAND/2; i++){
  164.             t = get_vlc2(gb, quant_vlc[1][i1].table, 9, 2);
  165.             *dst++ = mpc7_idx50[t];
  166.             *dst++ = mpc7_idx51[t];
  167.         }
  168.         break;
  169.     case  3: case  4: case  5: case  6: case  7:
  170.         i1 = get_bits1(gb);
  171.         for(i = 0; i < SAMPLES_PER_BAND; i++)
  172.             *dst++ = get_vlc2(gb, quant_vlc[idx-1][i1].table, 9, 2) - mpc7_quant_vlc_off[idx-1];
  173.         break;
  174.     case  8: case  9: case 10: case 11: case 12:
  175.     case 13: case 14: case 15: case 16: case 17:
  176.         t = (1 << (idx - 2)) - 1;
  177.         for(i = 0; i < SAMPLES_PER_BAND; i++)
  178.             *dst++ = get_bits(gb, idx - 1) - t;
  179.         break;
  180.     default: // case 0 and -2..-17
  181.         return;
  182.     }
  183. }
  184.  
  185. static int get_scale_idx(GetBitContext *gb, int ref)
  186. {
  187.     int t = get_vlc2(gb, dscf_vlc.table, MPC7_DSCF_BITS, 1) - 7;
  188.     if (t == 8)
  189.         return get_bits(gb, 6);
  190.     return ref + t;
  191. }
  192.  
  193. static int mpc7_decode_frame(AVCodecContext * avctx, void *data,
  194.                              int *got_frame_ptr, AVPacket *avpkt)
  195. {
  196.     AVFrame *frame     = data;
  197.     const uint8_t *buf = avpkt->data;
  198.     int buf_size;
  199.     MPCContext *c = avctx->priv_data;
  200.     GetBitContext gb;
  201.     int i, ch;
  202.     int mb = -1;
  203.     Band *bands = c->bands;
  204.     int off, ret, last_frame, skip;
  205.     int bits_used, bits_avail;
  206.  
  207.     memset(bands, 0, sizeof(*bands) * (c->maxbands + 1));
  208.  
  209.     buf_size = avpkt->size & ~3;
  210.     if (buf_size <= 0) {
  211.         av_log(avctx, AV_LOG_ERROR, "packet size is too small (%i bytes)\n",
  212.                avpkt->size);
  213.         return AVERROR_INVALIDDATA;
  214.     }
  215.     if (buf_size != avpkt->size) {
  216.         av_log(avctx, AV_LOG_WARNING, "packet size is not a multiple of 4. "
  217.                "extra bytes at the end will be skipped.\n");
  218.     }
  219.  
  220.     skip       = buf[0];
  221.     last_frame = buf[1];
  222.     buf       += 4;
  223.     buf_size  -= 4;
  224.  
  225.     /* get output buffer */
  226.     frame->nb_samples = MPC_FRAME_SIZE;
  227.     if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
  228.         return ret;
  229.  
  230.     av_fast_padded_malloc(&c->bits, &c->buf_size, buf_size);
  231.     if (!c->bits)
  232.         return AVERROR(ENOMEM);
  233.     c->dsp.bswap_buf((uint32_t *)c->bits, (const uint32_t *)buf, buf_size >> 2);
  234.     init_get_bits(&gb, c->bits, buf_size * 8);
  235.     skip_bits_long(&gb, skip);
  236.  
  237.     /* read subband indexes */
  238.     for(i = 0; i <= c->maxbands; i++){
  239.         for(ch = 0; ch < 2; ch++){
  240.             int t = 4;
  241.             if(i) t = get_vlc2(&gb, hdr_vlc.table, MPC7_HDR_BITS, 1) - 5;
  242.             if(t == 4) bands[i].res[ch] = get_bits(&gb, 4);
  243.             else bands[i].res[ch] = bands[i-1].res[ch] + t;
  244.             if (bands[i].res[ch] < -1 || bands[i].res[ch] > 17) {
  245.                 av_log(avctx, AV_LOG_ERROR, "subband index invalid\n");
  246.                 return AVERROR_INVALIDDATA;
  247.             }
  248.         }
  249.  
  250.         if(bands[i].res[0] || bands[i].res[1]){
  251.             mb = i;
  252.             if(c->MSS) bands[i].msf = get_bits1(&gb);
  253.         }
  254.     }
  255.     /* get scale indexes coding method */
  256.     for(i = 0; i <= mb; i++)
  257.         for(ch = 0; ch < 2; ch++)
  258.             if(bands[i].res[ch]) bands[i].scfi[ch] = get_vlc2(&gb, scfi_vlc.table, MPC7_SCFI_BITS, 1);
  259.     /* get scale indexes */
  260.     for(i = 0; i <= mb; i++){
  261.         for(ch = 0; ch < 2; ch++){
  262.             if(bands[i].res[ch]){
  263.                 bands[i].scf_idx[ch][2] = c->oldDSCF[ch][i];
  264.                 bands[i].scf_idx[ch][0] = get_scale_idx(&gb, bands[i].scf_idx[ch][2]);
  265.                 switch(bands[i].scfi[ch]){
  266.                 case 0:
  267.                     bands[i].scf_idx[ch][1] = get_scale_idx(&gb, bands[i].scf_idx[ch][0]);
  268.                     bands[i].scf_idx[ch][2] = get_scale_idx(&gb, bands[i].scf_idx[ch][1]);
  269.                     break;
  270.                 case 1:
  271.                     bands[i].scf_idx[ch][1] = get_scale_idx(&gb, bands[i].scf_idx[ch][0]);
  272.                     bands[i].scf_idx[ch][2] = bands[i].scf_idx[ch][1];
  273.                     break;
  274.                 case 2:
  275.                     bands[i].scf_idx[ch][1] = bands[i].scf_idx[ch][0];
  276.                     bands[i].scf_idx[ch][2] = get_scale_idx(&gb, bands[i].scf_idx[ch][1]);
  277.                     break;
  278.                 case 3:
  279.                     bands[i].scf_idx[ch][2] = bands[i].scf_idx[ch][1] = bands[i].scf_idx[ch][0];
  280.                     break;
  281.                 }
  282.                 c->oldDSCF[ch][i] = bands[i].scf_idx[ch][2];
  283.             }
  284.         }
  285.     }
  286.     /* get quantizers */
  287.     memset(c->Q, 0, sizeof(c->Q));
  288.     off = 0;
  289.     for(i = 0; i < BANDS; i++, off += SAMPLES_PER_BAND)
  290.         for(ch = 0; ch < 2; ch++)
  291.             idx_to_quant(c, &gb, bands[i].res[ch], c->Q[ch] + off);
  292.  
  293.     ff_mpc_dequantize_and_synth(c, mb, (int16_t **)frame->extended_data, 2);
  294.     if(last_frame)
  295.         frame->nb_samples = c->lastframelen;
  296.  
  297.     bits_used = get_bits_count(&gb);
  298.     bits_avail = buf_size * 8;
  299.     if (!last_frame && ((bits_avail < bits_used) || (bits_used + 32 <= bits_avail))) {
  300.         av_log(avctx, AV_LOG_ERROR, "Error decoding frame: used %i of %i bits\n", bits_used, bits_avail);
  301.         return -1;
  302.     }
  303.     if(c->frames_to_skip){
  304.         c->frames_to_skip--;
  305.         *got_frame_ptr = 0;
  306.         return avpkt->size;
  307.     }
  308.  
  309.     *got_frame_ptr = 1;
  310.  
  311.     return avpkt->size;
  312. }
  313.  
  314. static void mpc7_decode_flush(AVCodecContext *avctx)
  315. {
  316.     MPCContext *c = avctx->priv_data;
  317.  
  318.     memset(c->oldDSCF, 0, sizeof(c->oldDSCF));
  319.     c->frames_to_skip = 32;
  320. }
  321.  
  322. static av_cold int mpc7_decode_close(AVCodecContext *avctx)
  323. {
  324.     MPCContext *c = avctx->priv_data;
  325.     av_freep(&c->bits);
  326.     c->buf_size = 0;
  327.     return 0;
  328. }
  329.  
  330. AVCodec ff_mpc7_decoder = {
  331.     .name           = "mpc7",
  332.     .long_name      = NULL_IF_CONFIG_SMALL("Musepack SV7"),
  333.     .type           = AVMEDIA_TYPE_AUDIO,
  334.     .id             = AV_CODEC_ID_MUSEPACK7,
  335.     .priv_data_size = sizeof(MPCContext),
  336.     .init           = mpc7_decode_init,
  337.     .close          = mpc7_decode_close,
  338.     .decode         = mpc7_decode_frame,
  339.     .flush          = mpc7_decode_flush,
  340.     .capabilities   = CODEC_CAP_DR1,
  341.     .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16P,
  342.                                                       AV_SAMPLE_FMT_NONE },
  343. };
  344.