33 #include "libavutil/common.h"
35 #define FREEZE_INTERVAL 128
39 #define MAX_FRAME_SIZE 32768
44 #define MAX_TRELLIS 16
50 for (i = 0; i < 2; i++) {
73 int frontier = 1 << avctx->
trellis;
76 for (i = 0; i < 2; i++) {
100 "allowed. Using %d instead of %d\n", new_frame_size,
116 "allowed. Using %d instead of %d\n", new_trellis,
129 35, 72, 110, 150, 190, 233, 276, 323,
130 370, 422, 473, 530, 587, 650, 714, 786,
131 858, 940, 1023, 1121, 1219, 1339, 1458, 1612,
132 1765, 1980, 2195, 2557, 2919
136 int *xlow,
int *xhigh)
142 *xlow = xout1 + xout2 >> 14;
143 *xhigh = xout1 - xout2 >> 14;
154 int diff = av_clip_int16(xhigh - state->s_predictor);
155 int pred = 141 * state->scale_factor >> 8;
157 return ((diff ^ (diff >> (
sizeof(diff)*8-1))) < pred) + 2*(diff >= 0);
162 int diff = av_clip_int16(xlow - state->s_predictor);
164 int limit = diff ^ (diff >> (
sizeof(diff)*8-1));
166 limit = limit + 1 << 10;
167 if (limit >
low_quant[8] * state->scale_factor)
169 while (i < 29 && limit >
low_quant[i] * state->scale_factor)
171 return (diff < 0 ? (i < 2 ? 63 : 33) : 61) - i;
176 const int16_t *samples)
179 int frontier = 1 << trellis;
182 int pathn[2] = {0, 0}, froze = -1;
185 for (i = 0; i < 2; i++) {
187 nodes_next[i] = c->
nodep_buf[i] + frontier;
189 nodes[i][0] = c->
node_buf[i] + frontier;
190 nodes[i][0]->
ssd = 0;
191 nodes[i][0]->
path = 0;
192 nodes[i][0]->state = c->
band[i];
195 for (i = 0; i < nb_samples >> 1; i++) {
198 int heap_pos[2] = {0, 0};
200 for (j = 0; j < 2; j++) {
201 next[j] = c->
node_buf[j] + frontier*(i & 1);
202 memset(nodes_next[j], 0, frontier *
sizeof(**nodes_next));
207 for (j = 0; j < frontier && nodes[0][j]; j++) {
213 int range = j < frontier/2 ? 4 : 0;
216 int ilow =
encode_low(&cur_node->state, xlow);
218 for (k = ilow - range; k <= ilow + range && k <= 63; k += 4) {
219 int decoded, dec_diff, pos;
226 decoded = av_clip((cur_node->state.scale_factor *
228 + cur_node->state.s_predictor, -16384, 16383);
229 dec_diff = xlow - decoded;
231 #define STORE_NODE(index, UPDATE, VALUE)\
232 ssd = cur_node->ssd + dec_diff*dec_diff;\
235 if (ssd < cur_node->ssd)\
237 if (heap_pos[index] < frontier) {\
238 pos = heap_pos[index]++;\
239 assert(pathn[index] < FREEZE_INTERVAL * frontier);\
240 node = nodes_next[index][pos] = next[index]++;\
241 node->path = pathn[index]++;\
245 pos = (frontier>>1) + (heap_pos[index] & ((frontier>>1) - 1));\
246 if (ssd >= nodes_next[index][pos]->ssd)\
249 node = nodes_next[index][pos];\
252 node->state = cur_node->state;\
254 c->paths[index][node->path].value = VALUE;\
255 c->paths[index][node->path].prev = cur_node->path;\
259 int parent = (pos - 1) >> 1;\
260 if (nodes_next[index][parent]->ssd <= ssd)\
262 FFSWAP(struct TrellisNode*, nodes_next[index][parent],\
263 nodes_next[index][pos]);\
270 for (j = 0; j < frontier && nodes[1][j]; j++) {
278 for (ihigh = 0; ihigh < 4; ihigh++) {
279 int dhigh, decoded, dec_diff, pos;
283 dhigh = cur_node->state.scale_factor *
285 decoded = av_clip(dhigh + cur_node->state.s_predictor,
287 dec_diff = xhigh - decoded;
293 for (j = 0; j < 2; j++) {
296 if (nodes[j][0]->
ssd > (1 << 16)) {
297 for (k = 1; k < frontier && nodes[j][k]; k++)
298 nodes[j][k]->
ssd -= nodes[j][0]->
ssd;
299 nodes[j][0]->ssd = 0;
304 p[0] = &c->
paths[0][nodes[0][0]->path];
305 p[1] = &c->
paths[1][nodes[1][0]->path];
306 for (j = i; j > froze; j--) {
307 dst[j] = p[1]->value << 6 | p[0]->value;
312 pathn[0] = pathn[1] = 0;
313 memset(nodes[0] + 1, 0, (frontier - 1)*
sizeof(**nodes));
314 memset(nodes[1] + 1, 0, (frontier - 1)*
sizeof(**nodes));
320 for (j = i; j > froze; j--) {
321 dst[j] = p[1]->value << 6 | p[0]->value;
325 c->
band[0] = nodes[0][0]->state;
326 c->
band[1] = nodes[1][0]->state;
330 const int16_t *samples)
332 int xlow, xhigh, ilow, ihigh;
339 *dst = ihigh << 6 | ilow;
344 const int16_t *samples)
347 for (i = 0; i < nb_samples; i += 2)
352 const AVFrame *frame,
int *got_packet_ptr)
355 const int16_t *samples = (
const int16_t *)frame->
data[0];
356 int nb_samples, out_size, ret;
372 if (nb_samples < frame->nb_samples) {
373 int16_t last_samples[2] = { samples[nb_samples], samples[nb_samples] };
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
struct G722Context::TrellisNode ** nodep_buf[2]
This structure describes decoded (raw) audio or video data.
#define AV_LOG_WARNING
Something somehow does not look correct.
void av_log(void *avcl, int level, const char *fmt,...) av_printf_format(3
Send the specified message to the log if the level is less than or equal to the current av_log_level...
struct G722Context::TrellisPath * paths[2]
static void filter_samples(G722Context *c, const int16_t *samples, int *xlow, int *xhigh)
static void g722_encode_no_trellis(G722Context *c, uint8_t *dst, int nb_samples, const int16_t *samples)
void av_freep(void *ptr)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
static int encode_high(const struct G722Band *state, int xhigh)
#define PREV_SAMPLES_BUF_SIZE
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
const char * name
Name of the codec implementation.
static av_cold int g722_encode_init(AVCodecContext *avctx)
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
struct G722Context::TrellisNode * node_buf[2]
#define CODEC_CAP_SMALL_LAST_FRAME
Codec can be fed a final frame with a smaller size.
const int16_t ff_g722_low_inv_quant6[64]
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
void ff_g722_apply_qmf(const int16_t *prev_samples, int *xout1, int *xout2)
int16_t prev_samples[PREV_SAMPLES_BUF_SIZE]
memory of past decoded samples
AVCodec ff_adpcm_g722_encoder
Libavcodec external API header.
struct G722Context::G722Band band[2]
static void g722_encode_trellis(G722Context *c, int trellis, uint8_t *dst, int nb_samples, const int16_t *samples)
static av_cold int g722_encode_close(AVCodecContext *avctx)
static int encode_low(const struct G722Band *state, int xlow)
int ff_alloc_packet(AVPacket *avpkt, int size)
Check AVPacket size and/or allocate data.
void ff_g722_update_low_predictor(struct G722Band *band, const int ilow)
static const float pred[4]
int frame_size
Number of samples per channel in an audio frame.
static const int16_t low_quant[33]
AVSampleFormat
Audio Sample Formats.
main external API structure.
static void close(AVCodecParserContext *s)
#define FFSWAP(type, a, b)
common internal api header.
int prev_samples_pos
the number of values in prev_samples
static av_cold int init(AVCodecParserContext *s)
int trellis
trellis RD quantization
#define STORE_NODE(index, UPDATE, VALUE)
const int16_t ff_g722_high_inv_quant[4]
int channels
number of audio channels
static av_always_inline void encode_byte(G722Context *c, uint8_t *dst, const int16_t *samples)
static int g722_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr)
static av_always_inline int64_t ff_samples_to_time_base(AVCodecContext *avctx, int64_t samples)
Rescale from sample rate to AVCodecContext.time_base.
void ff_g722_update_high_predictor(struct G722Band *band, const int dhigh, const int ihigh)
This structure stores compressed data.
int16_t scale_factor
delayed quantizer scale factor
int nb_samples
number of audio samples (per channel) described by this frame
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
#define AV_NOPTS_VALUE
Undefined timestamp value.
void * av_mallocz(size_t size) av_malloc_attrib 1(1)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...