30 #include "libavutil/avassert.h"
34 #include "libavutil/common.h"
36 #define FREEZE_INTERVAL 128
40 #define MAX_FRAME_SIZE 32768
45 #define MAX_TRELLIS 16
51 for (i = 0; i < 2; i++) {
74 int frontier = 1 << avctx->
trellis;
77 for (i = 0; i < 2; i++) {
101 "allowed. Using %d instead of %d\n", new_frame_size,
117 "allowed. Using %d instead of %d\n", new_trellis,
130 35, 72, 110, 150, 190, 233, 276, 323,
131 370, 422, 473, 530, 587, 650, 714, 786,
132 858, 940, 1023, 1121, 1219, 1339, 1458, 1612,
133 1765, 1980, 2195, 2557, 2919
137 int *xlow,
int *xhigh)
143 *xlow = xout1 + xout2 >> 14;
144 *xhigh = xout1 - xout2 >> 14;
155 int diff = av_clip_int16(xhigh - state->s_predictor);
156 int pred = 141 * state->scale_factor >> 8;
158 return ((diff ^ (diff >> (
sizeof(diff)*8-1))) < pred) + 2*(diff >= 0);
163 int diff = av_clip_int16(xlow - state->s_predictor);
165 int limit = diff ^ (diff >> (
sizeof(diff)*8-1));
167 limit = limit + 1 << 10;
168 if (limit >
low_quant[8] * state->scale_factor)
170 while (i < 29 && limit >
low_quant[i] * state->scale_factor)
172 return (diff < 0 ? (i < 2 ? 63 : 33) : 61) - i;
177 const int16_t *samples)
180 int frontier = 1 << trellis;
183 int pathn[2] = {0, 0}, froze = -1;
186 for (i = 0; i < 2; i++) {
188 nodes_next[i] = c->
nodep_buf[i] + frontier;
190 nodes[i][0] = c->
node_buf[i] + frontier;
191 nodes[i][0]->
ssd = 0;
192 nodes[i][0]->
path = 0;
193 nodes[i][0]->state = c->
band[i];
196 for (i = 0; i < nb_samples >> 1; i++) {
199 int heap_pos[2] = {0, 0};
201 for (j = 0; j < 2; j++) {
202 next[j] = c->
node_buf[j] + frontier*(i & 1);
203 memset(nodes_next[j], 0, frontier *
sizeof(**nodes_next));
208 for (j = 0; j < frontier && nodes[0][j]; j++) {
214 int range = j < frontier/2 ? 4 : 0;
217 int ilow =
encode_low(&cur_node->state, xlow);
219 for (k = ilow - range; k <= ilow + range && k <= 63; k += 4) {
220 int decoded, dec_diff, pos;
227 decoded = av_clip((cur_node->state.scale_factor *
229 + cur_node->state.s_predictor, -16384, 16383);
230 dec_diff = xlow - decoded;
232 #define STORE_NODE(index, UPDATE, VALUE)\
233 ssd = cur_node->ssd + dec_diff*dec_diff;\
236 if (ssd < cur_node->ssd)\
238 if (heap_pos[index] < frontier) {\
239 pos = heap_pos[index]++;\
240 av_assert2(pathn[index] < FREEZE_INTERVAL * frontier);\
241 node = nodes_next[index][pos] = next[index]++;\
242 node->path = pathn[index]++;\
246 pos = (frontier>>1) + (heap_pos[index] & ((frontier>>1) - 1));\
247 if (ssd >= nodes_next[index][pos]->ssd)\
250 node = nodes_next[index][pos];\
253 node->state = cur_node->state;\
255 c->paths[index][node->path].value = VALUE;\
256 c->paths[index][node->path].prev = cur_node->path;\
260 int parent = (pos - 1) >> 1;\
261 if (nodes_next[index][parent]->ssd <= ssd)\
263 FFSWAP(struct TrellisNode*, nodes_next[index][parent],\
264 nodes_next[index][pos]);\
271 for (j = 0; j < frontier && nodes[1][j]; j++) {
279 for (ihigh = 0; ihigh < 4; ihigh++) {
280 int dhigh, decoded, dec_diff, pos;
284 dhigh = cur_node->state.scale_factor *
286 decoded = av_clip(dhigh + cur_node->state.s_predictor,
288 dec_diff = xhigh - decoded;
294 for (j = 0; j < 2; j++) {
297 if (nodes[j][0]->
ssd > (1 << 16)) {
298 for (k = 1; k < frontier && nodes[j][k]; k++)
299 nodes[j][k]->
ssd -= nodes[j][0]->
ssd;
300 nodes[j][0]->ssd = 0;
305 p[0] = &c->
paths[0][nodes[0][0]->path];
306 p[1] = &c->
paths[1][nodes[1][0]->path];
307 for (j = i; j > froze; j--) {
308 dst[j] = p[1]->value << 6 | p[0]->value;
313 pathn[0] = pathn[1] = 0;
314 memset(nodes[0] + 1, 0, (frontier - 1)*
sizeof(**nodes));
315 memset(nodes[1] + 1, 0, (frontier - 1)*
sizeof(**nodes));
321 for (j = i; j > froze; j--) {
322 dst[j] = p[1]->value << 6 | p[0]->value;
326 c->
band[0] = nodes[0][0]->state;
327 c->
band[1] = nodes[1][0]->state;
331 const int16_t *samples)
333 int xlow, xhigh, ilow, ihigh;
340 *dst = ihigh << 6 | ilow;
345 const int16_t *samples)
348 for (i = 0; i < nb_samples; i += 2)
356 const int16_t *samples = (
const int16_t *)frame->
data[0];
357 int nb_samples, out_size,
ret;
371 if (nb_samples < frame->nb_samples) {
372 int16_t last_samples[2] = { samples[nb_samples], samples[nb_samples] };
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size)
Check AVPacket size and/or allocate data.
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.
static av_cold int init(AVCodecContext *avctx)
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 FFSWAP(type, a, b)
#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)
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.
AVSampleFormat
Audio Sample Formats.
static const int16_t low_quant[33]
main external API structure.
static void close(AVCodecParserContext *s)
common internal api header.
int prev_samples_pos
the number of values in prev_samples
int trellis
trellis RD quantization
#define STORE_NODE(index, UPDATE, VALUE)
#define AVERROR_INVALIDDATA
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 enum AVSampleFormat sample_fmts[]
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 ...