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);
130  if (c->prev_samples_pos >= PREV_SAMPLES_BUF_SIZE) {
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),
151  .priv_class = &g722_decoder_class,
152  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,
153 };
AVCodec
AVCodec.
Definition: codec.h:202
FF_CODEC_CAP_INIT_THREADSAFE
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
Definition: internal.h:42
g722_decode_frame
static int g722_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
Definition: g722dec.c:86
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
opt.h
AVCodecContext::channel_layout
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:1043
OFFSET
#define OFFSET(x)
Definition: g722dec.c:44
PREV_SAMPLES_BUF_SIZE
#define PREV_SAMPLES_BUF_SIZE
Definition: g722.h:32
AV_CH_LAYOUT_MONO
#define AV_CH_LAYOUT_MONO
Definition: channel_layout.h:90
ff_g722_low_inv_quant4
const int16_t ff_g722_low_inv_quant4[16]
Definition: g722.c:59
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:303
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:373
AVOption
AVOption.
Definition: opt.h:247
data
const char data[16]
Definition: mxf.c:143
AV_CODEC_ID_ADPCM_G722
@ AV_CODEC_ID_ADPCM_G722
Definition: codec_id.h:380
g722_decode_init
static av_cold int g722_decode_init(AVCodecContext *avctx)
Definition: g722dec.c:58
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:468
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:380
ff_g722_low_inv_quant6
const int16_t ff_g722_low_inv_quant6[64]
Definition: g722.c:63
GetBitContext
Definition: get_bits.h:62
g722_decoder_class
static const AVClass g722_decoder_class
Definition: g722dec.c:51
av_cold
#define av_cold
Definition: attributes.h:90
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:678
decode
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
ff_g722_high_inv_quant
const int16_t ff_g722_high_inv_quant[4]
Definition: g722.c:51
get_bits.h
ff_adpcm_g722_decoder
const AVCodec ff_adpcm_g722_decoder
Definition: g722dec.c:142
low_inv_quant5
static const int16_t low_inv_quant5[32]
Definition: g722dec.c:75
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
G722Context
Definition: g722.h:34
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
av_clip_int16
#define av_clip_int16
Definition: common.h:111
NULL
#define NULL
Definition: coverity.c:32
av_clip_intp2
#define av_clip_intp2
Definition: common.h:117
ff_g722_update_high_predictor
void ff_g722_update_high_predictor(struct G722Band *band, const int dhigh, const int ihigh)
Definition: g722.c:154
options
static const AVOption options[]
Definition: g722dec.c:46
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
AD
#define AD
Definition: g722dec.c:45
c
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
AV_CODEC_CAP_CHANNEL_CONF
#define AV_CODEC_CAP_CHANNEL_CONF
Codec should fill in channel configuration and samplerate instead of container.
Definition: codec.h:109
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1652
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
AVPacket::size
int size
Definition: packet.h:374
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1000
low_inv_quants
static const int16_t *const low_inv_quants[3]
Definition: g722dec.c:82
g722.h
AVCodecContext::channels
int channels
number of audio channels
Definition: avcodec.h:993
AV_SAMPLE_FMT_S16
@ AV_SAMPLE_FMT_S16
signed 16 bits
Definition: samplefmt.h:61
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:209
avcodec.h
ret
ret
Definition: filter_design.txt:187
AVClass::class_name
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:71
frame
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
Definition: filter_design.txt:264
AVCodecContext
main external API structure.
Definition: avcodec.h:383
channel_layout.h
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:224
AVPacket
This structure stores compressed data.
Definition: packet.h:350
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:410
ff_g722_update_low_predictor
void ff_g722_update_low_predictor(struct G722Band *band, const int ilow)
Definition: g722.c:143
ff_g722dsp_init
av_cold void ff_g722dsp_init(G722DSPContext *c)
Definition: g722dsp.c:68