LCOV - code coverage report
Current view: top level - libavcodec - mace.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 62 69 89.9 %
Date: 2017-12-11 20:48:03 Functions: 6 6 100.0 %

          Line data    Source code
       1             : /*
       2             :  * MACE decoder
       3             :  * Copyright (c) 2002 Laszlo Torok <torokl@alpha.dfmk.hu>
       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             :  * MACE decoder.
      25             :  */
      26             : 
      27             : #include "avcodec.h"
      28             : #include "internal.h"
      29             : #include "libavutil/common.h"
      30             : 
      31             : /*
      32             :  * Adapted to libavcodec by Francois Revol <revol@free.fr>
      33             :  * (removed 68k REG stuff, changed types, added some statics and consts,
      34             :  * libavcodec api, context stuff, interlaced stereo out).
      35             :  */
      36             : 
      37             : static const int16_t MACEtab1[] = {-13, 8, 76, 222, 222, 76, 8, -13};
      38             : 
      39             : static const int16_t MACEtab3[] = {-18, 140, 140, -18};
      40             : 
      41             : static const int16_t MACEtab2[][4] = {
      42             :     {    37,    116,    206,    330}, {    39,    121,    216,    346},
      43             :     {    41,    127,    225,    361}, {    42,    132,    235,    377},
      44             :     {    44,    137,    245,    392}, {    46,    144,    256,    410},
      45             :     {    48,    150,    267,    428}, {    51,    157,    280,    449},
      46             :     {    53,    165,    293,    470}, {    55,    172,    306,    490},
      47             :     {    58,    179,    319,    511}, {    60,    187,    333,    534},
      48             :     {    63,    195,    348,    557}, {    66,    205,    364,    583},
      49             :     {    69,    214,    380,    609}, {    72,    223,    396,    635},
      50             :     {    75,    233,    414,    663}, {    79,    244,    433,    694},
      51             :     {    82,    254,    453,    725}, {    86,    265,    472,    756},
      52             :     {    90,    278,    495,    792}, {    94,    290,    516,    826},
      53             :     {    98,    303,    538,    862}, {   102,    316,    562,    901},
      54             :     {   107,    331,    588,    942}, {   112,    345,    614,    983},
      55             :     {   117,    361,    641,   1027}, {   122,    377,    670,   1074},
      56             :     {   127,    394,    701,   1123}, {   133,    411,    732,   1172},
      57             :     {   139,    430,    764,   1224}, {   145,    449,    799,   1280},
      58             :     {   152,    469,    835,   1337}, {   159,    490,    872,   1397},
      59             :     {   166,    512,    911,   1459}, {   173,    535,    951,   1523},
      60             :     {   181,    558,    993,   1590}, {   189,    584,   1038,   1663},
      61             :     {   197,    610,   1085,   1738}, {   206,    637,   1133,   1815},
      62             :     {   215,    665,   1183,   1895}, {   225,    695,   1237,   1980},
      63             :     {   235,    726,   1291,   2068}, {   246,    759,   1349,   2161},
      64             :     {   257,    792,   1409,   2257}, {   268,    828,   1472,   2357},
      65             :     {   280,    865,   1538,   2463}, {   293,    903,   1606,   2572},
      66             :     {   306,    944,   1678,   2688}, {   319,    986,   1753,   2807},
      67             :     {   334,   1030,   1832,   2933}, {   349,   1076,   1914,   3065},
      68             :     {   364,   1124,   1999,   3202}, {   380,   1174,   2088,   3344},
      69             :     {   398,   1227,   2182,   3494}, {   415,   1281,   2278,   3649},
      70             :     {   434,   1339,   2380,   3811}, {   453,   1398,   2486,   3982},
      71             :     {   473,   1461,   2598,   4160}, {   495,   1526,   2714,   4346},
      72             :     {   517,   1594,   2835,   4540}, {   540,   1665,   2961,   4741},
      73             :     {   564,   1740,   3093,   4953}, {   589,   1818,   3232,   5175},
      74             :     {   615,   1898,   3375,   5405}, {   643,   1984,   3527,   5647},
      75             :     {   671,   2072,   3683,   5898}, {   701,   2164,   3848,   6161},
      76             :     {   733,   2261,   4020,   6438}, {   766,   2362,   4199,   6724},
      77             :     {   800,   2467,   4386,   7024}, {   836,   2578,   4583,   7339},
      78             :     {   873,   2692,   4786,   7664}, {   912,   2813,   5001,   8008},
      79             :     {   952,   2938,   5223,   8364}, {   995,   3070,   5457,   8739},
      80             :     {  1039,   3207,   5701,   9129}, {  1086,   3350,   5956,   9537},
      81             :     {  1134,   3499,   6220,   9960}, {  1185,   3655,   6497,  10404},
      82             :     {  1238,   3818,   6788,  10869}, {  1293,   3989,   7091,  11355},
      83             :     {  1351,   4166,   7407,  11861}, {  1411,   4352,   7738,  12390},
      84             :     {  1474,   4547,   8084,  12946}, {  1540,   4750,   8444,  13522},
      85             :     {  1609,   4962,   8821,  14126}, {  1680,   5183,   9215,  14756},
      86             :     {  1756,   5415,   9626,  15415}, {  1834,   5657,  10057,  16104},
      87             :     {  1916,   5909,  10505,  16822}, {  2001,   6173,  10975,  17574},
      88             :     {  2091,   6448,  11463,  18356}, {  2184,   6736,  11974,  19175},
      89             :     {  2282,   7037,  12510,  20032}, {  2383,   7351,  13068,  20926},
      90             :     {  2490,   7679,  13652,  21861}, {  2601,   8021,  14260,  22834},
      91             :     {  2717,   8380,  14897,  23854}, {  2838,   8753,  15561,  24918},
      92             :     {  2965,   9144,  16256,  26031}, {  3097,   9553,  16982,  27193},
      93             :     {  3236,   9979,  17740,  28407}, {  3380,  10424,  18532,  29675},
      94             :     {  3531,  10890,  19359,  31000}, {  3688,  11375,  20222,  32382},
      95             :     {  3853,  11883,  21125,  32767}, {  4025,  12414,  22069,  32767},
      96             :     {  4205,  12967,  23053,  32767}, {  4392,  13546,  24082,  32767},
      97             :     {  4589,  14151,  25157,  32767}, {  4793,  14783,  26280,  32767},
      98             :     {  5007,  15442,  27452,  32767}, {  5231,  16132,  28678,  32767},
      99             :     {  5464,  16851,  29957,  32767}, {  5708,  17603,  31294,  32767},
     100             :     {  5963,  18389,  32691,  32767}, {  6229,  19210,  32767,  32767},
     101             :     {  6507,  20067,  32767,  32767}, {  6797,  20963,  32767,  32767},
     102             :     {  7101,  21899,  32767,  32767}, {  7418,  22876,  32767,  32767},
     103             :     {  7749,  23897,  32767,  32767}, {  8095,  24964,  32767,  32767},
     104             :     {  8456,  26078,  32767,  32767}, {  8833,  27242,  32767,  32767},
     105             :     {  9228,  28457,  32767,  32767}, {  9639,  29727,  32767,  32767}
     106             : };
     107             : 
     108             : static const int16_t MACEtab4[][2] = {
     109             :     {    64,    216}, {    67,    226}, {    70,    236}, {    74,    246},
     110             :     {    77,    257}, {    80,    268}, {    84,    280}, {    88,    294},
     111             :     {    92,    307}, {    96,    321}, {   100,    334}, {   104,    350},
     112             :     {   109,    365}, {   114,    382}, {   119,    399}, {   124,    416},
     113             :     {   130,    434}, {   136,    454}, {   142,    475}, {   148,    495},
     114             :     {   155,    519}, {   162,    541}, {   169,    564}, {   176,    590},
     115             :     {   185,    617}, {   193,    644}, {   201,    673}, {   210,    703},
     116             :     {   220,    735}, {   230,    767}, {   240,    801}, {   251,    838},
     117             :     {   262,    876}, {   274,    914}, {   286,    955}, {   299,    997},
     118             :     {   312,   1041}, {   326,   1089}, {   341,   1138}, {   356,   1188},
     119             :     {   372,   1241}, {   388,   1297}, {   406,   1354}, {   424,   1415},
     120             :     {   443,   1478}, {   462,   1544}, {   483,   1613}, {   505,   1684},
     121             :     {   527,   1760}, {   551,   1838}, {   576,   1921}, {   601,   2007},
     122             :     {   628,   2097}, {   656,   2190}, {   686,   2288}, {   716,   2389},
     123             :     {   748,   2496}, {   781,   2607}, {   816,   2724}, {   853,   2846},
     124             :     {   891,   2973}, {   930,   3104}, {   972,   3243}, {  1016,   3389},
     125             :     {  1061,   3539}, {  1108,   3698}, {  1158,   3862}, {  1209,   4035},
     126             :     {  1264,   4216}, {  1320,   4403}, {  1379,   4599}, {  1441,   4806},
     127             :     {  1505,   5019}, {  1572,   5244}, {  1642,   5477}, {  1715,   5722},
     128             :     {  1792,   5978}, {  1872,   6245}, {  1955,   6522}, {  2043,   6813},
     129             :     {  2134,   7118}, {  2229,   7436}, {  2329,   7767}, {  2432,   8114},
     130             :     {  2541,   8477}, {  2655,   8854}, {  2773,   9250}, {  2897,   9663},
     131             :     {  3026,  10094}, {  3162,  10546}, {  3303,  11016}, {  3450,  11508},
     132             :     {  3604,  12020}, {  3765,  12556}, {  3933,  13118}, {  4108,  13703},
     133             :     {  4292,  14315}, {  4483,  14953}, {  4683,  15621}, {  4892,  16318},
     134             :     {  5111,  17046}, {  5339,  17807}, {  5577,  18602}, {  5826,  19433},
     135             :     {  6086,  20300}, {  6358,  21205}, {  6642,  22152}, {  6938,  23141},
     136             :     {  7248,  24173}, {  7571,  25252}, {  7909,  26380}, {  8262,  27557},
     137             :     {  8631,  28786}, {  9016,  30072}, {  9419,  31413}, {  9839,  32767},
     138             :     { 10278,  32767}, { 10737,  32767}, { 11216,  32767}, { 11717,  32767},
     139             :     { 12240,  32767}, { 12786,  32767}, { 13356,  32767}, { 13953,  32767},
     140             :     { 14576,  32767}, { 15226,  32767}, { 15906,  32767}, { 16615,  32767}
     141             : };
     142             : 
     143             : static const struct {
     144             :     const int16_t *tab1; const int16_t *tab2; int stride;
     145             : } tabs[] = {
     146             :     {MACEtab1, &MACEtab2[0][0], 4},
     147             :     {MACEtab3, &MACEtab4[0][0], 2},
     148             :     {MACEtab1, &MACEtab2[0][0], 4}
     149             : };
     150             : 
     151             : #define QT_8S_2_16S(x) (((x) & 0xFF00) | (((x) >> 8) & 0xFF))
     152             : 
     153             : typedef struct ChannelData {
     154             :     int16_t index, factor, prev2, previous, level;
     155             : } ChannelData;
     156             : 
     157             : typedef struct MACEContext {
     158             :     ChannelData chd[2];
     159             : } MACEContext;
     160             : 
     161             : /**
     162             :  * MACE version of av_clip_int16(). We have to do this to keep binary
     163             :  * identical output to the binary decoder.
     164             :  */
     165     2636514 : static inline int16_t mace_broken_clip_int16(int n)
     166             : {
     167     2636514 :     if (n > 32767)
     168          57 :         return 32767;
     169     2636457 :     else if (n < -32768)
     170          77 :         return -32767;
     171             :     else
     172     2636380 :         return n;
     173             : }
     174             : 
     175     2636514 : static int16_t read_table(ChannelData *chd, uint8_t val, int tab_idx)
     176             : {
     177             :     int16_t current;
     178             : 
     179     2636514 :     if (val < tabs[tab_idx].stride)
     180     1322891 :         current = tabs[tab_idx].tab2[((chd->index & 0x7f0) >> 4) * tabs[tab_idx].stride + val];
     181             :     else
     182     1313623 :         current = - 1 - tabs[tab_idx].tab2[((chd->index & 0x7f0) >> 4)*tabs[tab_idx].stride + 2*tabs[tab_idx].stride-val-1];
     183             : 
     184     2636514 :     if (( chd->index += tabs[tab_idx].tab1[val]-(chd->index >> 5) ) < 0)
     185       49567 :       chd->index = 0;
     186             : 
     187     2636514 :     return current;
     188             : }
     189             : 
     190     1734894 : static void chomp3(ChannelData *chd, int16_t *output, uint8_t val, int tab_idx)
     191             : {
     192             : 
     193     1734894 :     int16_t current = read_table(chd, val, tab_idx);
     194             : 
     195     1734894 :     current = mace_broken_clip_int16(current + chd->level);
     196             : 
     197     1734894 :     chd->level = current - (current >> 3);
     198     1734894 :     *output = QT_8S_2_16S(current);
     199     1734894 : }
     200             : 
     201      901620 : static void chomp6(ChannelData *chd, int16_t *output, uint8_t val, int tab_idx)
     202             : {
     203      901620 :     int16_t current = read_table(chd, val, tab_idx);
     204             : 
     205      901620 :     if ((chd->previous ^ current) >= 0) {
     206      419434 :         chd->factor = FFMIN(chd->factor + 506, 32767);
     207             :     } else {
     208      482186 :         if (chd->factor - 314 < -32768)
     209           0 :             chd->factor = -32767;
     210             :         else
     211      482186 :             chd->factor -= 314;
     212             :     }
     213             : 
     214      901620 :     current = mace_broken_clip_int16(current + chd->level);
     215             : 
     216      901620 :     chd->level = (current*chd->factor) >> 15;
     217      901620 :     current >>= 1;
     218             : 
     219      901620 :     output[0] = QT_8S_2_16S(chd->previous + chd->prev2 -
     220             :                             ((chd->prev2-current) >> 2));
     221      901620 :     output[1] = QT_8S_2_16S(chd->previous + current +
     222             :                             ((chd->prev2-current) >> 2));
     223      901620 :     chd->prev2 = chd->previous;
     224      901620 :     chd->previous = current;
     225      901620 : }
     226             : 
     227          14 : static av_cold int mace_decode_init(AVCodecContext * avctx)
     228             : {
     229          14 :     if (avctx->channels > 2 || avctx->channels < 1)
     230           0 :         return AVERROR(EINVAL);
     231          14 :     avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
     232             : 
     233          14 :     return 0;
     234             : }
     235             : 
     236        2377 : static int mace_decode_frame(AVCodecContext *avctx, void *data,
     237             :                              int *got_frame_ptr, AVPacket *avpkt)
     238             : {
     239        2377 :     AVFrame *frame     = data;
     240        2377 :     const uint8_t *buf = avpkt->data;
     241        2377 :     int buf_size = avpkt->size;
     242             :     int16_t **samples;
     243        2377 :     MACEContext *ctx = avctx->priv_data;
     244             :     int i, j, k, l, ret;
     245        2377 :     int is_mace3 = (avctx->codec_id == AV_CODEC_ID_MACE3);
     246             : 
     247        2377 :     if (buf_size % (avctx->channels << is_mace3)) {
     248           0 :         av_log(avctx, AV_LOG_ERROR, "buffer size %d is odd\n", buf_size);
     249           0 :         buf_size -= buf_size % (avctx->channels << is_mace3);
     250           0 :         if (!buf_size)
     251           0 :             return AVERROR_INVALIDDATA;
     252             :     }
     253             : 
     254             :     /* get output buffer */
     255        2377 :     frame->nb_samples = 3 * (buf_size << (1 - is_mace3)) / avctx->channels;
     256        2377 :     if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
     257           0 :         return ret;
     258        2377 :     samples = (int16_t **)frame->extended_data;
     259             : 
     260        5908 :     for(i = 0; i < avctx->channels; i++) {
     261        3531 :         int16_t *output = samples[i];
     262             : 
     263      593220 :         for (j=0; j < buf_size / (avctx->channels << is_mace3); j++)
     264     1468527 :             for (k=0; k < (1 << is_mace3); k++) {
     265     2636514 :                 uint8_t pkt = buf[(i << is_mace3) +
     266     1757676 :                                   (j*avctx->channels << is_mace3) + k];
     267             : 
     268     2636514 :                 uint8_t val[2][3] = {{pkt >> 5, (pkt >> 3) & 3, pkt & 7 },
     269     1757676 :                                      {pkt & 7 , (pkt >> 3) & 3, pkt >> 5}};
     270             : 
     271     3515352 :                 for (l=0; l < 3; l++) {
     272     2636514 :                     if (is_mace3)
     273     1734894 :                         chomp3(&ctx->chd[i], output, val[1][l], l);
     274             :                     else
     275      901620 :                         chomp6(&ctx->chd[i], output, val[0][l], l);
     276             : 
     277     2636514 :                     output += 1 << (1-is_mace3);
     278             :                 }
     279             :             }
     280             :     }
     281             : 
     282        2377 :     *got_frame_ptr = 1;
     283             : 
     284        2377 :     return buf_size;
     285             : }
     286             : 
     287             : AVCodec ff_mace3_decoder = {
     288             :     .name           = "mace3",
     289             :     .long_name      = NULL_IF_CONFIG_SMALL("MACE (Macintosh Audio Compression/Expansion) 3:1"),
     290             :     .type           = AVMEDIA_TYPE_AUDIO,
     291             :     .id             = AV_CODEC_ID_MACE3,
     292             :     .priv_data_size = sizeof(MACEContext),
     293             :     .init           = mace_decode_init,
     294             :     .decode         = mace_decode_frame,
     295             :     .capabilities   = AV_CODEC_CAP_DR1,
     296             :     .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16P,
     297             :                                                       AV_SAMPLE_FMT_NONE },
     298             : };
     299             : 
     300             : AVCodec ff_mace6_decoder = {
     301             :     .name           = "mace6",
     302             :     .long_name      = NULL_IF_CONFIG_SMALL("MACE (Macintosh Audio Compression/Expansion) 6:1"),
     303             :     .type           = AVMEDIA_TYPE_AUDIO,
     304             :     .id             = AV_CODEC_ID_MACE6,
     305             :     .priv_data_size = sizeof(MACEContext),
     306             :     .init           = mace_decode_init,
     307             :     .decode         = mace_decode_frame,
     308             :     .capabilities   = AV_CODEC_CAP_DR1,
     309             :     .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16P,
     310             :                                                       AV_SAMPLE_FMT_NONE },
     311             : };

Generated by: LCOV version 1.13