G.729 decoding routine (skeleton, including parameters decoding).
[ffmpeg.git] / 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 static const G729FormatDescription format_g729_8k = {
84     .ac_index_bits     = {8,5},
85     .parity_bit        = 1,
86     .gc_1st_index_bits = GC_1ST_IDX_BITS_8K,
87     .gc_2nd_index_bits = GC_2ND_IDX_BITS_8K,
88     .fc_signs_bits     = 4,
89     .fc_indexes_bits   = 13,
90 };
91
92 static const G729FormatDescription format_g729d_6k4 = {
93     .ac_index_bits     = {8,4},
94     .parity_bit        = 0,
95     .gc_1st_index_bits = GC_1ST_IDX_BITS_6K4,
96     .gc_2nd_index_bits = GC_2ND_IDX_BITS_6K4,
97     .fc_signs_bits     = 2,
98     .fc_indexes_bits   = 9,
99 };
100
101 /**
102  * \brief pseudo random number generator
103  */
104 static inline uint16_t g729_prng(uint16_t value)
105 {
106     return 31821 * value + 13849;
107 }
108
109 /**
110  * Get parity bit of bit 2..7
111  */
112 static inline int get_parity(uint8_t value)
113 {
114    return (0x6996966996696996ULL >> (value >> 2)) & 1;
115 }
116
117 static av_cold int decoder_init(AVCodecContext * avctx)
118 {
119     if (avctx->channels != 1) {
120         av_log(avctx, AV_LOG_ERROR, "Only mono sound is supported (requested channels: %d).\n", avctx->channels);
121         return AVERROR_NOFMT;
122     }
123
124     /* Both 8kbit/s and 6.4kbit/s modes uses two subframes per frame. */
125     avctx->frame_size = SUBFRAME_SIZE << 1;
126
127     return 0;
128 }
129
130 static int decode_frame(AVCodecContext *avctx, void *data, int *data_size,
131                         AVPacket *avpkt)
132 {
133     const uint8_t *buf = avpkt->data;
134     int buf_size       = avpkt->size;
135     int16_t *out_frame = data;
136     GetBitContext gb;
137     G729FormatDescription format;
138     int frame_erasure = 0;    ///< frame erasure detected during decoding
139     int bad_pitch = 0;        ///< parity check failed
140     int i;
141     uint8_t ma_predictor;     ///< switched MA predictor of LSP quantizer
142     uint8_t quantizer_1st;    ///< first stage vector of quantizer
143     uint8_t quantizer_2nd_lo; ///< second stage lower vector of quantizer (size in bits)
144     uint8_t quantizer_2nd_hi; ///< second stage higher vector of quantizer (size in bits)
145
146     if (*data_size < SUBFRAME_SIZE << 2) {
147         av_log(avctx, AV_LOG_ERROR, "Error processing packet: output buffer too small\n");
148         return AVERROR(EIO);
149     }
150
151     if (buf_size == 10) {
152         format = format_g729_8k;
153         av_log(avctx, AV_LOG_DEBUG, "Packet type: %s\n", "G.729 @ 8kbit/s");
154     } else if (buf_size == 8) {
155         format = format_g729d_6k4;
156         av_log(avctx, AV_LOG_DEBUG, "Packet type: %s\n", "G.729D @ 6.4kbit/s");
157     } else {
158         av_log(avctx, AV_LOG_ERROR, "Packet size %d is unknown.\n", buf_size);
159         return (AVERROR_NOFMT);
160     }
161
162     for (i=0; i < buf_size; i++)
163         frame_erasure |= buf[i];
164     frame_erasure = !frame_erasure;
165
166     init_get_bits(&gb, buf, buf_size);
167
168     ma_predictor     = get_bits(&gb, 1);
169     quantizer_1st    = get_bits(&gb, VQ_1ST_BITS);
170     quantizer_2nd_lo = get_bits(&gb, VQ_2ND_BITS);
171     quantizer_2nd_hi = get_bits(&gb, VQ_2ND_BITS);
172
173     for (i = 0; i < 2; i++) {
174         uint8_t ac_index;      ///< adaptive codebook index
175         uint8_t pulses_signs;  ///< fixed-codebook vector pulse signs
176         int fc_indexes;        ///< fixed-codebook indexes
177         uint8_t gc_1st_index;  ///< gain codebook (first stage) index
178         uint8_t gc_2nd_index;  ///< gain codebook (second stage) index
179
180         ac_index      = get_bits(&gb, format.ac_index_bits[i]);
181         if(!i && format.parity_bit)
182             bad_pitch = get_parity(ac_index) == get_bits1(&gb);
183         fc_indexes    = get_bits(&gb, format.fc_indexes_bits);
184         pulses_signs  = get_bits(&gb, format.fc_signs_bits);
185         gc_1st_index  = get_bits(&gb, format.gc_1st_index_bits);
186         gc_2nd_index  = get_bits(&gb, format.gc_2nd_index_bits);
187
188         ff_acelp_weighted_vector_sum(fc + pitch_delay_int[i],
189                                      fc + pitch_delay_int[i],
190                                      fc, 1 << 14,
191                                      av_clip(ctx->gain_pitch, SHARP_MIN, SHARP_MAX),
192                                      0, 14,
193                                      SUBFRAME_SIZE - pitch_delay_int[i]);
194
195         if (frame_erasure) {
196             ctx->gain_pitch = (29491 * ctx->gain_pitch) >> 15; // 0.90 (0.15)
197             ctx->gain_code  = ( 2007 * ctx->gain_code ) >> 11; // 0.98 (0.11)
198
199             gain_corr_factor = 0;
200         } else {
201             ctx->gain_pitch  = cb_gain_1st_8k[gc_1st_index][0] +
202                                cb_gain_2nd_8k[gc_2nd_index][0];
203             gain_corr_factor = cb_gain_1st_8k[gc_1st_index][1] +
204                                cb_gain_2nd_8k[gc_2nd_index][1];
205
206         ff_acelp_weighted_vector_sum(ctx->exc + i * SUBFRAME_SIZE,
207                                      ctx->exc + i * SUBFRAME_SIZE, fc,
208                                      (!voicing && frame_erasure) ? 0 : ctx->gain_pitch,
209                                      ( voicing && frame_erasure) ? 0 : ctx->gain_code,
210                                      1 << 13, 14, SUBFRAME_SIZE);
211     }
212
213     *data_size = SUBFRAME_SIZE << 2;
214     return buf_size;
215 }
216
217 AVCodec g729_decoder =
218 {
219     "g729",
220     CODEC_TYPE_AUDIO,
221     CODEC_ID_G729,
222     sizeof(G729Context),
223     decoder_init,
224     NULL,
225     NULL,
226     decode_frame,
227     .long_name = NULL_IF_CONFIG_SMALL("G.729"),
228 };