Go to the documentation of this file.
39 #define FREEZE_INTERVAL 128
43 #define MAX_FRAME_SIZE 32768
48 #define MAX_TRELLIS 16
54 for (
i = 0;
i < 2;
i++) {
66 c->band[0].scale_factor = 8;
67 c->band[1].scale_factor = 2;
68 c->prev_samples_pos = 22;
83 "allowed. Using %d instead of %d\n", new_frame_size,
99 "allowed. Using %d instead of %d\n", new_trellis,
104 int frontier = 1 << avctx->
trellis;
107 for (
int i = 0;
i < 2;
i++) {
109 c->node_buf[
i] =
av_calloc(frontier, 2 *
sizeof(**
c->node_buf));
110 c->nodep_buf[
i] =
av_calloc(frontier, 2 *
sizeof(**
c->nodep_buf));
111 if (!
c->paths[
i] || !
c->node_buf[
i] || !
c->nodep_buf[
i])
123 35, 72, 110, 150, 190, 233, 276, 323,
124 370, 422, 473, 530, 587, 650, 714, 786,
125 858, 940, 1023, 1121, 1219, 1339, 1458, 1612,
126 1765, 1980, 2195, 2557, 2919
130 int *xlow,
int *xhigh)
133 c->prev_samples[
c->prev_samples_pos++] =
samples[0];
134 c->prev_samples[
c->prev_samples_pos++] =
samples[1];
135 c->dsp.apply_qmf(
c->prev_samples +
c->prev_samples_pos - 24, xout);
136 *xlow = xout[0] + xout[1] >> 14;
137 *xhigh = xout[0] - xout[1] >> 14;
139 memmove(
c->prev_samples,
140 c->prev_samples +
c->prev_samples_pos - 22,
141 22 *
sizeof(
c->prev_samples[0]));
142 c->prev_samples_pos = 22;
149 int pred = 141 *
state->scale_factor >> 8;
165 return (
diff < 0 ? (
i < 2 ? 63 : 33) : 61) -
i;
169 uint8_t *
dst,
int nb_samples,
173 int frontier = 1 << trellis;
176 int pathn[2] = {0, 0}, froze = -1;
179 for (
i = 0;
i < 2;
i++) {
180 nodes[
i] =
c->nodep_buf[
i];
181 nodes_next[
i] =
c->nodep_buf[
i] + frontier;
182 memset(
c->nodep_buf[
i], 0, 2 * frontier *
sizeof(*
c->nodep_buf[
i]));
183 nodes[
i][0] =
c->node_buf[
i] + frontier;
184 nodes[
i][0]->
ssd = 0;
185 nodes[
i][0]->
path = 0;
186 nodes[
i][0]->state =
c->band[
i];
189 for (
i = 0; i < nb_samples >> 1;
i++) {
192 int heap_pos[2] = {0, 0};
194 for (j = 0; j < 2; j++) {
195 next[j] =
c->node_buf[j] + frontier*(
i & 1);
196 memset(nodes_next[j], 0, frontier *
sizeof(**nodes_next));
201 for (j = 0; j < frontier && nodes[0][j]; j++) {
207 int range = j < frontier/2 ? 4 : 0;
210 int ilow =
encode_low(&cur_node->state, xlow);
212 for (k = ilow -
range; k <= ilow +
range && k <= 63; k += 4) {
213 int decoded, dec_diff,
pos;
222 + cur_node->state.s_predictor, 14);
223 dec_diff = xlow - decoded;
225 #define STORE_NODE(index, UPDATE, VALUE)\
226 ssd = cur_node->ssd + dec_diff*dec_diff;\
229 if (ssd < cur_node->ssd)\
231 if (heap_pos[index] < frontier) {\
232 pos = heap_pos[index]++;\
233 av_assert2(pathn[index] < FREEZE_INTERVAL * frontier);\
234 node = nodes_next[index][pos] = next[index]++;\
235 node->path = pathn[index]++;\
239 pos = (frontier>>1) + (heap_pos[index] & ((frontier>>1) - 1));\
240 if (ssd >= nodes_next[index][pos]->ssd)\
243 node = nodes_next[index][pos];\
246 node->state = cur_node->state;\
248 c->paths[index][node->path].value = VALUE;\
249 c->paths[index][node->path].prev = cur_node->path;\
253 int parent = (pos - 1) >> 1;\
254 if (nodes_next[index][parent]->ssd <= ssd)\
256 FFSWAP(struct TrellisNode*, nodes_next[index][parent],\
257 nodes_next[index][pos]);\
264 for (j = 0; j < frontier && nodes[1][j]; j++) {
272 for (ihigh = 0; ihigh < 4; ihigh++) {
273 int dhigh, decoded, dec_diff,
pos;
277 dhigh = cur_node->state.scale_factor *
279 decoded =
av_clip_intp2(dhigh + cur_node->state.s_predictor, 14);
280 dec_diff = xhigh - decoded;
286 for (j = 0; j < 2; j++) {
289 if (nodes[j][0]->
ssd > (1 << 16)) {
290 for (k = 1; k < frontier && nodes[j][k]; k++)
291 nodes[j][k]->
ssd -= nodes[j][0]->
ssd;
292 nodes[j][0]->ssd = 0;
297 p[0] = &
c->paths[0][nodes[0][0]->path];
298 p[1] = &
c->paths[1][nodes[1][0]->path];
299 for (j =
i; j > froze; j--) {
300 dst[j] = p[1]->value << 6 | p[0]->value;
301 p[0] = &
c->paths[0][p[0]->
prev];
302 p[1] = &
c->paths[1][p[1]->
prev];
305 pathn[0] = pathn[1] = 0;
306 memset(nodes[0] + 1, 0, (frontier - 1)*
sizeof(**nodes));
307 memset(nodes[1] + 1, 0, (frontier - 1)*
sizeof(**nodes));
311 p[0] = &
c->paths[0][nodes[0][0]->
path];
312 p[1] = &
c->paths[1][nodes[1][0]->
path];
313 for (j =
i; j > froze; j--) {
314 dst[j] = p[1]->value << 6 | p[0]->value;
315 p[0] = &
c->paths[0][p[0]->
prev];
316 p[1] = &
c->paths[1][p[1]->
prev];
318 c->band[0] = nodes[0][0]->state;
319 c->band[1] = nodes[1][0]->state;
325 int xlow, xhigh, ilow, ihigh;
336 uint8_t *
dst,
int nb_samples,
340 for (
i = 0;
i < nb_samples;
i += 2)
348 const int16_t *
samples = (
const int16_t *)
frame->data[0];
355 nb_samples =
frame->nb_samples - (
frame->nb_samples & 1);
363 if (nb_samples < frame->nb_samples) {
364 int16_t last_samples[2] = {
samples[nb_samples],
samples[nb_samples] };
int frame_size
Number of samples per channel in an audio frame.
#define AV_LOG_WARNING
Something somehow does not look correct.
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
#define PREV_SAMPLES_BUF_SIZE
This structure describes decoded (raw) audio or video data.
const FFCodec ff_adpcm_g722_encoder
static int encode_high(const struct G722Band *state, int xhigh)
static void filter_samples(G722Context *c, const int16_t *samples, int *xlow, int *xhigh)
static av_cold int g722_encode_init(AVCodecContext *avctx)
AVCodec p
The public AVCodec.
static void g722_encode_no_trellis(G722Context *c, uint8_t *dst, int nb_samples, const int16_t *samples)
const int16_t ff_g722_low_inv_quant6[64]
int initial_padding
Audio only.
#define FF_CODEC_ENCODE_CB(func)
const int16_t ff_g722_high_inv_quant[4]
#define AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE
This encoder can reorder user opaque values from input AVFrames and return them with corresponding ou...
#define CODEC_LONG_NAME(str)
void ff_g722_update_high_predictor(struct G722Band *band, const int dhigh, const int ihigh)
static void g722_encode_trellis(G722Context *c, int trellis, uint8_t *dst, int nb_samples, const int16_t *samples)
static av_always_inline int64_t ff_samples_to_time_base(const AVCodecContext *avctx, int64_t samples)
Rescale from sample rate to AVCodecContext.time_base.
static av_cold int g722_encode_close(AVCodecContext *avctx)
int trellis
trellis RD quantization
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
int(* init)(AVBSFContext *ctx)
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
An AVChannelLayout holds information about the channel layout of audio data.
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
static const int16_t low_quant[33]
#define AV_NOPTS_VALUE
Undefined timestamp value.
static int encode_low(const struct G722Band *state, int xlow)
static av_always_inline int diff(const struct color_info *a, const struct color_info *b, const int trans_thresh)
#define i(width, name, range_min, range_max)
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
AVSampleFormat
Audio sample formats.
@ AV_SAMPLE_FMT_S16
signed 16 bits
const char * name
Name of the codec implementation.
void * av_calloc(size_t nmemb, size_t size)
static double limit(double x)
static const float pred[4]
#define FFSWAP(type, a, b)
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
main external API structure.
#define STORE_NODE(index, UPDATE, VALUE)
int ff_get_encode_buffer(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int flags)
Get a buffer for a packet.
Filter the word “frame” indicates either a video frame or a group of audio samples
static int g722_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr)
#define AV_CHANNEL_LAYOUT_MONO
This structure stores compressed data.
void ff_g722_update_low_predictor(struct G722Band *band, const int ilow)
av_cold void ff_g722dsp_init(G722DSPContext *c)
#define AV_CODEC_CAP_SMALL_LAST_FRAME
Codec can be fed a final frame with a smaller size.
static av_always_inline void encode_byte(G722Context *c, uint8_t *dst, const int16_t *samples)