FFmpeg
g722dec.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) CMU 1993 Computer Science, Speech Group
3  * Chengxiang Lu and Alex Hauptmann
4  * Copyright (c) 2005 Steve Underwood <steveu at coppice.org>
5  * Copyright (c) 2009 Kenan Gillet
6  * Copyright (c) 2010 Martin Storsjo
7  *
8  * This file is part of FFmpeg.
9  *
10  * FFmpeg is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU Lesser General Public
12  * License as published by the Free Software Foundation; either
13  * version 2.1 of the License, or (at your option) any later version.
14  *
15  * FFmpeg is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18  * Lesser General Public License for more details.
19  *
20  * You should have received a copy of the GNU Lesser General Public
21  * License along with FFmpeg; if not, write to the Free Software
22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23  */
24 
25 /**
26  * @file
27  * G.722 ADPCM audio decoder
28  *
29  * This G.722 decoder is a bit-exact implementation of the ITU G.722
30  * specification for all three specified bitrates - 64000bps, 56000bps
31  * and 48000bps. It passes the ITU tests.
32  *
33  * @note For the 56000bps and 48000bps bitrates, the lowest 1 or 2 bits
34  * respectively of each byte are ignored.
35  */
36 
38 #include "libavutil/opt.h"
39 #include "avcodec.h"
40 #include "get_bits.h"
41 #include "g722.h"
42 #include "internal.h"
43 
44 #define OFFSET(x) offsetof(G722Context, x)
45 #define AD AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM
46 static const AVOption options[] = {
47  { "bits_per_codeword", "Bits per G722 codeword", OFFSET(bits_per_codeword), AV_OPT_TYPE_INT, { .i64 = 8 }, 6, 8, AD },
48  { NULL }
49 };
50 
51 static const AVClass g722_decoder_class = {
52  .class_name = "g722 decoder",
53  .item_name = av_default_item_name,
54  .option = options,
55  .version = LIBAVUTIL_VERSION_INT,
56 };
57 
59 {
60  G722Context *c = avctx->priv_data;
61 
62  avctx->channels = 1;
65 
66  c->band[0].scale_factor = 8;
67  c->band[1].scale_factor = 2;
68  c->prev_samples_pos = 22;
69 
70  ff_g722dsp_init(&c->dsp);
71 
72  return 0;
73 }
74 
75 static const int16_t low_inv_quant5[32] = {
76  -35, -35, -2919, -2195, -1765, -1458, -1219, -1023,
77  -858, -714, -587, -473, -370, -276, -190, -110,
78  2919, 2195, 1765, 1458, 1219, 1023, 858, 714,
79  587, 473, 370, 276, 190, 110, 35, -35
80 };
81 
82 static const int16_t * const low_inv_quants[3] = { ff_g722_low_inv_quant6,
85 
86 static int g722_decode_frame(AVCodecContext *avctx, void *data,
87  int *got_frame_ptr, AVPacket *avpkt)
88 {
89  G722Context *c = avctx->priv_data;
90  AVFrame *frame = data;
91  int16_t *out_buf;
92  int j, ret;
93  const int skip = 8 - c->bits_per_codeword;
94  const int16_t *quantizer_table = low_inv_quants[skip];
95  GetBitContext gb;
96 
97  /* get output buffer */
98  frame->nb_samples = avpkt->size * 2;
99  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
100  return ret;
101  out_buf = (int16_t *)frame->data[0];
102 
103  ret = init_get_bits8(&gb, avpkt->data, avpkt->size);
104  if (ret < 0)
105  return ret;
106 
107  for (j = 0; j < avpkt->size; j++) {
108  int ilow, ihigh, rlow, rhigh, dhigh;
109  int xout[2];
110 
111  ihigh = get_bits(&gb, 2);
112  ilow = get_bits(&gb, 6 - skip);
113  skip_bits(&gb, skip);
114 
115  rlow = av_clip_intp2((c->band[0].scale_factor * quantizer_table[ilow] >> 10)
116  + c->band[0].s_predictor, 14);
117 
118  ff_g722_update_low_predictor(&c->band[0], ilow >> (2 - skip));
119 
120  dhigh = c->band[1].scale_factor * ff_g722_high_inv_quant[ihigh] >> 10;
121  rhigh = av_clip_intp2(dhigh + c->band[1].s_predictor, 14);
122 
123  ff_g722_update_high_predictor(&c->band[1], dhigh, ihigh);
124 
125  c->prev_samples[c->prev_samples_pos++] = rlow + rhigh;
126  c->prev_samples[c->prev_samples_pos++] = rlow - rhigh;
127  c->dsp.apply_qmf(c->prev_samples + c->prev_samples_pos - 24, xout);
128  *out_buf++ = av_clip_int16(xout[0] >> 11);
129  *out_buf++ = av_clip_int16(xout[1] >> 11);
131  memmove(c->prev_samples, c->prev_samples + c->prev_samples_pos - 22,
132  22 * sizeof(c->prev_samples[0]));
133  c->prev_samples_pos = 22;
134  }
135  }
136 
137  *got_frame_ptr = 1;
138 
139  return avpkt->size;
140 }
141 
143  .name = "g722",
144  .long_name = NULL_IF_CONFIG_SMALL("G.722 ADPCM"),
145  .type = AVMEDIA_TYPE_AUDIO,
147  .priv_data_size = sizeof(G722Context),
150  .capabilities = AV_CODEC_CAP_DR1,
151  .priv_class = &g722_decoder_class,
152 };
#define OFFSET(x)
Definition: g722dec.c:44
#define NULL
Definition: coverity.c:32
const int16_t ff_g722_low_inv_quant4[16]
Definition: g722.c:59
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
AVOption.
Definition: opt.h:246
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
AVCodec ff_adpcm_g722_decoder
Definition: g722dec.c:142
int size
Definition: avcodec.h:1481
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:191
static av_cold int g722_decode_init(AVCodecContext *avctx)
Definition: g722dec.c:58
AVCodec.
Definition: avcodec.h:3492
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:72
void(* apply_qmf)(const int16_t *prev_samples, int xout[2])
Definition: g722dsp.h:27
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:2236
#define av_cold
Definition: attributes.h:82
AVOptions.
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
#define PREV_SAMPLES_BUF_SIZE
Definition: g722.h:32
uint8_t * data
Definition: avcodec.h:1480
bitstream reader API header.
static const AVClass g722_decoder_class
Definition: g722dec.c:51
int bits_per_codeword
Definition: g722.h:36
const int16_t ff_g722_low_inv_quant6[64]
Definition: g722.c:63
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
int16_t prev_samples[PREV_SAMPLES_BUF_SIZE]
memory of past decoded samples
Definition: g722.h:37
const char * name
Name of the codec implementation.
Definition: avcodec.h:3499
static const int16_t *const low_inv_quants[3]
Definition: g722dec.c:82
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:2279
struct G722Context::G722Band band[2]
audio channel layout utility functions
static const AVOption options[]
Definition: g722dec.c:46
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
void ff_g722_update_low_predictor(struct G722Band *band, const int ilow)
Definition: g722.c:143
static const int16_t low_inv_quant5[32]
Definition: g722dec.c:75
G722DSPContext dsp
Definition: g722.h:66
Libavcodec external API header.
#define AD
Definition: g722dec.c:45
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:677
main external API structure.
Definition: avcodec.h:1568
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1968
Describe the class of an AVClass context structure.
Definition: log.h:67
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:467
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:309
common internal api header.
signed 16 bits
Definition: samplefmt.h:61
int prev_samples_pos
the number of values in prev_samples
Definition: g722.h:38
void * priv_data
Definition: avcodec.h:1595
static int g722_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
Definition: g722dec.c:86
const int16_t ff_g722_high_inv_quant[4]
Definition: g722.c:51
int channels
number of audio channels
Definition: avcodec.h:2229
int16_t s_predictor
predictor output value
Definition: g722.h:44
av_cold void ff_g722dsp_init(G722DSPContext *c)
Definition: g722dsp.c:68
void ff_g722_update_high_predictor(struct G722Band *band, const int dhigh, const int ihigh)
Definition: g722.c:154
#define AV_CH_LAYOUT_MONO
This structure stores compressed data.
Definition: avcodec.h:1457
int16_t scale_factor
delayed quantizer scale factor
Definition: g722.h:52
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:361
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:984