Line data    Source code

       1             : /*
       2             :  * MQ-coder decoder
       3             :  * Copyright (c) 2007 Kamil Nowosad
       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             :  * MQ-coder decoder
      24             :  * @file
      25             :  * @author Kamil Nowosad
      26             :  */
      27             : 
      28             : #include "mqc.h"
      29             : 
      30    15972024 : static void bytein(MqcState *mqc)
      31             : {
      32    15972024 :     if (*mqc->bp == 0xff) {
      33      447940 :         if (*(mqc->bp + 1) > 0x8f)
      34      385409 :             mqc->c++;
      35             :         else {
      36       62531 :             mqc->bp++;
      37       62531 :             mqc->c += 2 + 0xfe00 - (*mqc->bp << 9);
      38             :         }
      39             :     } else {
      40    15524084 :         mqc->bp++;
      41    15524084 :         mqc->c += 1 + 0xff00 - (*mqc->bp << 8);
      42             :     }
      43    15972024 : }
      44             : 
      45    88273842 : static int exchange(MqcState *mqc, uint8_t *cxstate, int lps)
      46             : {
      47             :     int d;
      48    88273842 :     if ((mqc->a < ff_mqc_qe[*cxstate]) ^ (!lps)) {
      49    46699411 :         if (lps)
      50     8992607 :             mqc->a = ff_mqc_qe[*cxstate];
      51    46699411 :         d = *cxstate & 1;
      52    46699411 :         *cxstate = ff_mqc_nmps[*cxstate];
      53             :     } else {
      54    41574431 :         if (lps)
      55    34304675 :             mqc->a = ff_mqc_qe[*cxstate];
      56    41574431 :         d = 1 - (*cxstate & 1);
      57    41574431 :         *cxstate = ff_mqc_nlps[*cxstate];
      58             :     }
      59             :     // do RENORMD: see ISO/IEC 15444-1:2002 §C.3.3
      60             :     do {
      61   124024020 :         if (!(mqc->c & 0xff)) {
      62    15609296 :             mqc->c -= 0x100;
      63    15609296 :             bytein(mqc);
      64             :         }
      65   124024020 :         mqc->a += mqc->a;
      66   124024020 :         mqc->c += mqc->c;
      67   124024020 :     } while (!(mqc->a & 0x8000));
      68    88273842 :     return d;
      69             : }
      70             : 
      71      362728 : void ff_mqc_initdec(MqcState *mqc, uint8_t *bp, int raw, int reset)
      72             : {
      73      362728 :     mqc->raw = raw;
      74      362728 :     if (reset)
      75      362728 :         ff_mqc_init_contexts(mqc);
      76      362728 :     mqc->bp = bp;
      77      362728 :     mqc->c  = (*mqc->bp ^ 0xff) << 16;
      78      362728 :     bytein(mqc);
      79      362728 :     mqc->c = mqc->c << 7;
      80      362728 :     mqc->a = 0x8000;
      81      362728 : }
      82             : 
      83           0 : static int mqc_decode_bypass(MqcState *mqc) {
      84           0 :     int bit = !(mqc->c & 0x40000000);
      85           0 :     if (!(mqc->c & 0xff)) {
      86           0 :         mqc->c -= 0x100;
      87           0 :         bytein(mqc);
      88             :     }
      89           0 :     mqc->c += mqc->c;
      90           0 :     return bit;
      91             : }
      92             : 
      93   182845733 : int ff_mqc_decode(MqcState *mqc, uint8_t *cxstate)
      94             : {
      95   182845733 :     if (mqc->raw)
      96           0 :         return mqc_decode_bypass(mqc);
      97   182845733 :     mqc->a -= ff_mqc_qe[*cxstate];
      98   182845733 :     if ((mqc->c >> 16) < mqc->a) {
      99   139548451 :         if (mqc->a & 0x8000)
     100    94571891 :             return *cxstate & 1;
     101             :         else
     102    44976560 :             return exchange(mqc, cxstate, 0);
     103             :     } else {
     104    43297282 :         mqc->c -= mqc->a << 16;
     105    43297282 :         return exchange(mqc, cxstate, 1);
     106             :     }
     107             : }