libavcodec/g729dec.c

   1 /*
   2  * G.729 decoder
   3  * Copyright (c) 2008 Vladimir Voroshilov
   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 #include <stdlib.h>
  22 #include <inttypes.h>
  23 #include <limits.h>
  24 #include <stdio.h>
  25 #include <string.h>
  26 #include <math.h>
  27 #include <assert.h>
  28
  29 #include "avcodec.h"
  30 #include "libavutil/avutil.h"
  31 #include "get_bits.h"
  32
  33 #include "g729.h"
  34 #include "lsp.h"
  35 #include "celp_math.h"
  36 #include "acelp_filters.h"
  37 #include "acelp_pitch_delay.h"
  38 #include "acelp_vectors.h"
  39 #include "g729data.h"
  40
  41 /**
  42  * minimum quantized LSF value (3.2.4)
  43  * 0.005 in Q13
  44  */
  45 #define LSFQ_MIN                   40
  46
  47 /**
  48  * maximum quantized LSF value (3.2.4)
  49  * 3.135 in Q13
  50  */
  51 #define LSFQ_MAX                   25681
  52
  53 /**
  54  * minimum LSF distance (3.2.4)
  55  * 0.0391 in Q13
  56  */
  57 #define LSFQ_DIFF_MIN              321
  58
  59 /**
  60  * minimum gain pitch value (3.8, Equation 47)
  61  * 0.2 in (1.14)
  62  */
  63 #define SHARP_MIN                  3277
  64
  65 /**
  66  * maximum gain pitch value (3.8, Equation 47)
  67  * (EE) This does not comply with the specification.
  68  * Specification says about 0.8, which should be
  69  * 13107 in (1.14), but reference C code uses
  70  * 13017 (equals to 0.7945) instead of it.
  71  */
  72 #define SHARP_MAX                  13017
  73
  74 typedef struct {
  75     uint8_t ac_index_bits[2];   ///< adaptive codebook index for second subframe (size in bits)
  76     uint8_t parity_bit;         ///< parity bit for pitch delay
  77     uint8_t gc_1st_index_bits;  ///< gain codebook (first stage) index (size in bits)
  78     uint8_t gc_2nd_index_bits;  ///< gain codebook (second stage) index (size in bits)
  79     uint8_t fc_signs_bits;      ///< number of pulses in fixed-codebook vector
  80     uint8_t fc_indexes_bits;    ///< size (in bits) of fixed-codebook index entry
  81 } G729FormatDescription;
  82
  83 typedef struct {
  84     int16_t lsp_buf[2][10];     ///< (0.15) LSP coefficients (previous and current frames) (3.2.5)
  85     int16_t *lsp[2];            ///< pointers to lsp_buf
  86 }  G729Context;
  87
  88 static const G729FormatDescription format_g729_8k = {
  89     .ac_index_bits     = {8,5},
  90     .parity_bit        = 1,
  91     .gc_1st_index_bits = GC_1ST_IDX_BITS_8K,
  92     .gc_2nd_index_bits = GC_2ND_IDX_BITS_8K,
  93     .fc_signs_bits     = 4,
  94     .fc_indexes_bits   = 13,
  95 };
  96
  97 static const G729FormatDescription format_g729d_6k4 = {
  98     .ac_index_bits     = {8,4},
  99     .parity_bit        = 0,
 100     .gc_1st_index_bits = GC_1ST_IDX_BITS_6K4,
 101     .gc_2nd_index_bits = GC_2ND_IDX_BITS_6K4,
 102     .fc_signs_bits     = 2,
 103     .fc_indexes_bits   = 9,
 104 };
 105
 106 /**
 107  * \brief pseudo random number generator
 108  */
 109 static inline uint16_t g729_prng(uint16_t value)
 110 {
 111     return 31821 * value + 13849;
 112 }
 113
 114 /**
 115  * Get parity bit of bit 2..7
 116  */
 117 static inline int get_parity(uint8_t value)
 118 {
 119    return (0x6996966996696996ULL >> (value >> 2)) & 1;
 120 }
 121
 122 static av_cold int decoder_init(AVCodecContext * avctx)
 123 {
 124     if (avctx->channels != 1) {
 125         av_log(avctx, AV_LOG_ERROR, "Only mono sound is supported (requested channels: %d).\n", avctx->channels);
 126         return AVERROR_NOFMT;
 127     }
 128
 129     /* Both 8kbit/s and 6.4kbit/s modes uses two subframes per frame. */
 130     avctx->frame_size = SUBFRAME_SIZE << 1;
 131
 132     ctx->lsp[0] = ctx->lsp_buf[0];
 133     ctx->lsp[1] = ctx->lsp_buf[1];
 134     memcpy(ctx->lsp[0], lsp_init, 10 * sizeof(int16_t));
 135
 136     return 0;
 137 }
 138
 139 static int decode_frame(AVCodecContext *avctx, void *data, int *data_size,
 140                         AVPacket *avpkt)
 141 {
 142     const uint8_t *buf = avpkt->data;
 143     int buf_size       = avpkt->size;
 144     int16_t *out_frame = data;
 145     GetBitContext gb;
 146     G729FormatDescription format;
 147     int frame_erasure = 0;    ///< frame erasure detected during decoding
 148     int bad_pitch = 0;        ///< parity check failed
 149     int i;
 150     G729Context *ctx = avctx->priv_data;
 151     int16_t lp[2][11];           // (3.12)
 152     uint8_t ma_predictor;     ///< switched MA predictor of LSP quantizer
 153     uint8_t quantizer_1st;    ///< first stage vector of quantizer
 154     uint8_t quantizer_2nd_lo; ///< second stage lower vector of quantizer (size in bits)
 155     uint8_t quantizer_2nd_hi; ///< second stage higher vector of quantizer (size in bits)
 156
 157     if (*data_size < SUBFRAME_SIZE << 2) {
 158         av_log(avctx, AV_LOG_ERROR, "Error processing packet: output buffer too small\n");
 159         return AVERROR(EIO);
 160     }
 161
 162     if (buf_size == 10) {
 163         format = format_g729_8k;
 164         av_log(avctx, AV_LOG_DEBUG, "Packet type: %s\n", "G.729 @ 8kbit/s");
 165     } else if (buf_size == 8) {
 166         format = format_g729d_6k4;
 167         av_log(avctx, AV_LOG_DEBUG, "Packet type: %s\n", "G.729D @ 6.4kbit/s");
 168     } else {
 169         av_log(avctx, AV_LOG_ERROR, "Packet size %d is unknown.\n", buf_size);
 170         return (AVERROR_NOFMT);
 171     }
 172
 173     for (i=0; i < buf_size; i++)
 174         frame_erasure |= buf[i];
 175     frame_erasure = !frame_erasure;
 176
 177     init_get_bits(&gb, buf, buf_size);
 178
 179     ma_predictor     = get_bits(&gb, 1);
 180     quantizer_1st    = get_bits(&gb, VQ_1ST_BITS);
 181     quantizer_2nd_lo = get_bits(&gb, VQ_2ND_BITS);
 182     quantizer_2nd_hi = get_bits(&gb, VQ_2ND_BITS);
 183
 184     ff_acelp_lsf2lsp(ctx->lsp[1], ctx->lsfq, 10);
 185
 186     ff_acelp_lp_decode(&lp[0][0], &lp[1][0], ctx->lsp[1], ctx->lsp[0], 10);
 187
 188     FFSWAP(int16_t*, ctx->lsp[1], ctx->lsp[0]);
 189
 190     for (i = 0; i < 2; i++) {
 191         uint8_t ac_index;      ///< adaptive codebook index
 192         uint8_t pulses_signs;  ///< fixed-codebook vector pulse signs
 193         int fc_indexes;        ///< fixed-codebook indexes
 194         uint8_t gc_1st_index;  ///< gain codebook (first stage) index
 195         uint8_t gc_2nd_index;  ///< gain codebook (second stage) index
 196
 197         ac_index      = get_bits(&gb, format.ac_index_bits[i]);
 198         if(!i && format.parity_bit)
 199             bad_pitch = get_parity(ac_index) == get_bits1(&gb);
 200         fc_indexes    = get_bits(&gb, format.fc_indexes_bits);
 201         pulses_signs  = get_bits(&gb, format.fc_signs_bits);
 202         gc_1st_index  = get_bits(&gb, format.gc_1st_index_bits);
 203         gc_2nd_index  = get_bits(&gb, format.gc_2nd_index_bits);
 204
 205         ff_acelp_weighted_vector_sum(fc + pitch_delay_int[i],
 206                                      fc + pitch_delay_int[i],
 207                                      fc, 1 << 14,
 208                                      av_clip(ctx->gain_pitch, SHARP_MIN, SHARP_MAX),
 209                                      0, 14,
 210                                      SUBFRAME_SIZE - pitch_delay_int[i]);
 211
 212         if (frame_erasure) {
 213             ctx->gain_pitch = (29491 * ctx->gain_pitch) >> 15; // 0.90 (0.15)
 214             ctx->gain_code  = ( 2007 * ctx->gain_code ) >> 11; // 0.98 (0.11)
 215
 216             gain_corr_factor = 0;
 217         } else {
 218             ctx->gain_pitch  = cb_gain_1st_8k[gc_1st_index][0] +
 219                                cb_gain_2nd_8k[gc_2nd_index][0];
 220             gain_corr_factor = cb_gain_1st_8k[gc_1st_index][1] +
 221                                cb_gain_2nd_8k[gc_2nd_index][1];
 222
 223         ff_acelp_weighted_vector_sum(ctx->exc + i * SUBFRAME_SIZE,
 224                                      ctx->exc + i * SUBFRAME_SIZE, fc,
 225                                      (!voicing && frame_erasure) ? 0 : ctx->gain_pitch,
 226                                      ( voicing && frame_erasure) ? 0 : ctx->gain_code,
 227                                      1 << 13, 14, SUBFRAME_SIZE);
 228     }
 229
 230     *data_size = SUBFRAME_SIZE << 2;
 231     return buf_size;
 232 }
 233
 234 AVCodec g729_decoder =
 235 {
 236     "g729",
 237     CODEC_TYPE_AUDIO,
 238     CODEC_ID_G729,
 239     sizeof(G729Context),
 240     decoder_init,
 241     NULL,
 242     NULL,
 243     decode_frame,
 244     .long_name = NULL_IF_CONFIG_SMALL("G.729"),
 245 };