Chiebot-Mirror
/
FFmpeg
mirror of https://github.com/FFmpeg/FFmpeg.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

cosmetics: pretty-print flacenc.c

Browse Source 
Originally committed as revision 24597 to svn://svn.ffmpeg.org/ffmpeg/trunk
oldabi
Justin Ruggles 15 years ago
parent 965a3ddb1f
commit e35b689ebd
1 changed files with 344 additions and 325 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 201
      libavcodec/flacenc.c

201
libavcodec/flacenc.c
Unescape View File

@ -98,8 +98,9 @@ typedef struct FlacEncodeContext {
struct AVMD5 *md5ctx;
} FlacEncodeContext;
/**
* Write streaminfo metadata block to byte array
* Write streaminfo metadata block to byte array.
*/
static void write_streaminfo(FlacEncodeContext *s, uint8_t *header)
{
@ -123,9 +124,10 @@ static void write_streaminfo(FlacEncodeContext *s, uint8_t *header)
memcpy(&header[18], s->md5sum, 16);
}
/**
* Set blocksize based on samplerate
* Choose the closest predefined blocksize >= BLOCK_TIME_MS milliseconds
* Set blocksize based on samplerate.
* Choose the closest predefined blocksize >= BLOCK_TIME_MS milliseconds.
*/
static int select_blocksize(int samplerate, int block_time_ms)
{
@ -137,13 +139,15 @@ static int select_blocksize(int samplerate, int block_time_ms)
blocksize = ff_flac_blocksize_table[1];
target = (samplerate * block_time_ms) / 1000;
for (i = 0; i < 16; i++) {
if(target >= ff_flac_blocksize_table[i] && ff_flac_blocksize_table[i] > blocksize) {
if (target >= ff_flac_blocksize_table[i] &&
ff_flac_blocksize_table[i] > blocksize) {
blocksize = ff_flac_blocksize_table[i];
}
}
return blocksize;
}
static av_cold int flac_encode_init(AVCodecContext *avctx)
{
int freq = avctx->sample_rate;
@ -156,13 +160,11 @@ static av_cold int flac_encode_init(AVCodecContext *avctx)
dsputil_init(&s->dsp, avctx);
if(avctx->sample_fmt != SAMPLE_FMT_S16) {
if (avctx->sample_fmt != SAMPLE_FMT_S16)
return -1;
}
if(channels < 1 || channels > FLAC_MAX_CHANNELS) {
if (channels < 1 || channels > FLAC_MAX_CHANNELS)
return -1;
}
s->channels = channels;
/* find samplerate in table */
@ -194,11 +196,10 @@ static av_cold int flac_encode_init(AVCodecContext *avctx)
}
/* set compression option defaults based on avctx->compression_level */
if(avctx->compression_level < 0) {
if (avctx->compression_level < 0)
s->options.compression_level = 5;
} else {
else
s->options.compression_level = avctx->compression_level;
}
av_log(avctx, AV_LOG_DEBUG, " compression: %d\n", s->options.compression_level);
level = s->options.compression_level;
@ -209,18 +210,22 @@ static av_cold int flac_encode_init(AVCodecContext *avctx)
}
s->options.block_time_ms = ((int[]){ 27, 27, 27,105,105,105,105,105,105,105,105,105,105})[level];
s->options.lpc_type = ((int[]){ AV_LPC_TYPE_FIXED, AV_LPC_TYPE_FIXED, AV_LPC_TYPE_FIXED,
AV_LPC_TYPE_LEVINSON, AV_LPC_TYPE_LEVINSON, AV_LPC_TYPE_LEVINSON,
AV_LPC_TYPE_LEVINSON, AV_LPC_TYPE_LEVINSON, AV_LPC_TYPE_LEVINSON,
AV_LPC_TYPE_LEVINSON, AV_LPC_TYPE_LEVINSON, AV_LPC_TYPE_LEVINSON,
AV_LPC_TYPE_LEVINSON})[level];
s->options.min_prediction_order = ((int[]){ 2, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1})[level];
s->options.max_prediction_order = ((int[]){ 3, 4, 4, 6, 8, 8, 8, 8, 12, 12, 12, 32, 32})[level];
s->options.prediction_order_method = ((int[]){ ORDER_METHOD_EST, ORDER_METHOD_EST, ORDER_METHOD_EST,
ORDER_METHOD_EST, ORDER_METHOD_EST, ORDER_METHOD_EST,
ORDER_METHOD_4LEVEL, ORDER_METHOD_LOG, ORDER_METHOD_4LEVEL,
ORDER_METHOD_LOG, ORDER_METHOD_SEARCH, ORDER_METHOD_LOG,
ORDER_METHOD_SEARCH})[level];
s->options.min_partition_order = ((int[]){ 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0})[level];
s->options.max_partition_order = ((int[]){ 2, 2, 3, 3, 3, 8, 8, 8, 8, 8, 8, 8, 8})[level];
@ -412,6 +417,7 @@ static av_cold int flac_encode_init(AVCodecContext *avctx)
return 0;
}
static void init_frame(FlacEncodeContext *s)
{
int i, ch;
@ -438,13 +444,13 @@ static void init_frame(FlacEncodeContext *s)
}
}
for(ch=0; ch<s->channels; ch++) {
for (ch = 0; ch < s->channels; ch++)
frame->subframes[ch].obits = 16;
}
}
/**
* Copy channel-interleaved input samples into separate subframes
* Copy channel-interleaved input samples into separate subframes.
*/
static void copy_samples(FlacEncodeContext *s, const int16_t *samples)
{
@ -452,18 +458,16 @@ static void copy_samples(FlacEncodeContext *s, const int16_t *samples)
FlacFrame *frame;
frame = &s->frame;
for(i=0,j=0; i<frame->blocksize; i++) {
for(ch=0; ch<s->channels; ch++,j++) {
for (i = 0, j = 0; i < frame->blocksize; i++)
for (ch = 0; ch < s->channels; ch++, j++)
frame->subframes[ch].samples[i] = samples[j];
}
}
}
#define rice_encode_count(sum, n, k) (((n)*((k)+1))+((sum-(n>>1))>>(k)))
/**
* Solve for d/dk(rice_encode_count) = n-((sum-(n>>1))>>(k+1)) = 0
* Solve for d/dk(rice_encode_count) = n-((sum-(n>>1))>>(k+1)) = 0.
*/
static int find_optimal_param(uint32_t sum, int n)
{
@ -477,6 +481,7 @@ static int find_optimal_param(uint32_t sum, int n)
return FFMIN(k, MAX_RICE_PARAM);
}
static uint32_t calc_optimal_rice_params(RiceContext *rc, int porder,
uint32_t *sums, int n, int pred_order)
{
@ -500,6 +505,7 @@ static uint32_t calc_optimal_rice_params(RiceContext *rc, int porder,
return all_bits;
}
static void calc_sums(int pmin, int pmax, uint32_t *data, int n, int pred_order,
uint32_t sums[][MAX_PARTITIONS])
{
@ -513,20 +519,19 @@ static void calc_sums(int pmin, int pmax, uint32_t *data, int n, int pred_order,
res_end = &data[n >> pmax];
for (i = 0; i < parts; i++) {
uint32_t sum = 0;
while(res < res_end){
while (res < res_end)
sum += *(res++);
}
sums[pmax][i] = sum;
res_end += n >> pmax;
}
/* sums for lower levels */
for (i = pmax - 1; i >= pmin; i--) {
parts = (1 << i);
for(j=0; j<parts; j++) {
for (j = 0; j < parts; j++)
sums[i][j] = sums[i+1][2*j] + sums[i+1][2*j+1];
}
}
}
static uint32_t calc_rice_params(RiceContext *rc, int pmin, int pmax,
int32_t *data, int n, int pred_order)
@ -543,9 +548,8 @@ static uint32_t calc_rice_params(RiceContext *rc, int pmin, int pmax,
assert(pmin <= pmax);
udata = av_malloc(n * sizeof(uint32_t));
for(i=0; i<n; i++) {
for (i = 0; i < n; i++)
udata[i] = (2*data[i]) ^ (data[i]>>31);
}
calc_sums(pmin, pmax, udata, n, pred_order, sums);
@ -563,6 +567,7 @@ static uint32_t calc_rice_params(RiceContext *rc, int pmin, int pmax,
return bits[opt_porder];
}
static int get_max_p_order(int max_porder, int n, int order)
{
int porder = FFMIN(max_porder, av_log2(n^(n-1)));
@ -571,6 +576,7 @@ static int get_max_p_order(int max_porder, int n, int order)
return porder;
}
static uint32_t calc_rice_params_fixed(RiceContext *rc, int pmin, int pmax,
int32_t *data, int n, int pred_order,
int bps)
@ -583,6 +589,7 @@ static uint32_t calc_rice_params_fixed(RiceContext *rc, int pmin, int pmax,
return bits;
}
static uint32_t calc_rice_params_lpc(RiceContext *rc, int pmin, int pmax,
int32_t *data, int n, int pred_order,
int bps, int precision)
@ -595,20 +602,21 @@ static uint32_t calc_rice_params_lpc(RiceContext *rc, int pmin, int pmax,
return bits;
}
static void encode_residual_verbatim(int32_t *res, int32_t *smp, int n)
{
assert(n > 0);
memcpy(res, smp, n * sizeof(int32_t));
}
static void encode_residual_fixed(int32_t *res, const int32_t *smp, int n,
int order)
{
int i;
for(i=0; i<order; i++) {
for (i = 0; i < order; i++)
res[i] = smp[i];
}
if (order == 0) {
for (i = order; i < n; i++)
@ -652,6 +660,7 @@ static void encode_residual_fixed(int32_t *res, const int32_t *smp, int n,
}
}
#define LPC1(x) {\
int c = coefs[(x)-1];\
p0 += c * s;\
@ -659,9 +668,9 @@ static void encode_residual_fixed(int32_t *res, const int32_t *smp, int n,
p1 += c * s;\
}
static av_always_inline void encode_residual_lpc_unrolled(
int32_t *res, const int32_t *smp, int n,
int order, const int32_t *coefs, int shift, int big)
static av_always_inline void encode_residual_lpc_unrolled(int32_t *res,
const int32_t *smp, int n, int order,
const int32_t *coefs, int shift, int big)
{
int i;
for (i = order; i < n; i += 2) {
@ -719,13 +728,13 @@ static av_always_inline void encode_residual_lpc_unrolled(
}
}
static void encode_residual_lpc(int32_t *res, const int32_t *smp, int n,
int order, const int32_t *coefs, int shift)
{
int i;
for(i=0; i<order; i++) {
for (i = 0; i < order; i++)
res[i] = smp[i];
}
#if CONFIG_SMALL
for (i = order; i < n; i += 2) {
int j;
@ -755,6 +764,7 @@ static void encode_residual_lpc(int32_t *res, const int32_t *smp, int n,
#endif
}
static int encode_residual(FlacEncodeContext *ctx, int ch)
{
int i, n;
@ -773,9 +783,9 @@ static int encode_residual(FlacEncodeContext *ctx, int ch)
n = frame->blocksize;
/* CONSTANT */
for(i=1; i<n; i++) {
if(smp[i] != smp[0]) break;
}
for (i = 1; i < n; i++)
if(smp[i] != smp[0])
break;
if (i == n) {
sub->type = sub->type_code = FLAC_SUBFRAME_CONSTANT;
res[0] = smp[0];
@ -800,17 +810,17 @@ static int encode_residual(FlacEncodeContext *ctx, int ch)
if (ctx->options.lpc_type == AV_LPC_TYPE_NONE ||
ctx->options.lpc_type == AV_LPC_TYPE_FIXED || n <= max_order) {
uint32_t bits[MAX_FIXED_ORDER+1];
if(max_order > MAX_FIXED_ORDER) max_order = MAX_FIXED_ORDER;
if (max_order > MAX_FIXED_ORDER)
max_order = MAX_FIXED_ORDER;
opt_order = 0;
bits[0] = UINT32_MAX;
for (i = min_order; i <= max_order; i++) {
encode_residual_fixed(res, smp, n, i);
bits[i] = calc_rice_params_fixed(&sub->rc, min_porder, max_porder, res,
n, i, sub->obits);
if(bits[i] < bits[opt_order]) {
if (bits[i] < bits[opt_order])
opt_order = i;
}
}
sub->order = opt_order;
sub->type = FLAC_SUBFRAME_FIXED;
sub->type_code = sub->type | sub->order;
@ -839,7 +849,8 @@ static int encode_residual(FlacEncodeContext *ctx, int ch)
bits[opt_index] = UINT32_MAX;
for (i = levels-1; i >= 0; i--) {
order = min_order + (((max_order-min_order+1) * (i+1)) / levels)-1;
if(order < 0) order = 0;
if (order < 0)
order = 0;
encode_residual_lpc(res, smp, n, order+1, coefs[order], shift[order]);
bits[i] = calc_rice_params_lpc(&sub->rc, min_porder, max_porder,
res, n, order+1, sub->obits, precision);
@ -858,10 +869,9 @@ static int encode_residual(FlacEncodeContext *ctx, int ch)
encode_residual_lpc(res, smp, n, i+1, coefs[i], shift[i]);
bits[i] = calc_rice_params_lpc(&sub->rc, min_porder, max_porder,
res, n, i+1, sub->obits, precision);
if(bits[i] < bits[opt_order]) {
if (bits[i] < bits[opt_order])
opt_order = i;
}
}
opt_order++;
} else if (omethod == ORDER_METHOD_LOG) {
uint32_t bits[MAX_LPC_ORDER];
@ -877,7 +887,8 @@ static int encode_residual(FlacEncodeContext *ctx, int ch)
continue;
encode_residual_lpc(res, smp, n, i+1, coefs[i], shift[i]);
bits[i] = calc_rice_params_lpc(&sub->rc, min_porder, max_porder,
res, n, i+1, sub->obits, precision);
res, n, i+1, sub->obits,
precision);
if (bits[i] < bits[opt_order])
opt_order = i;
}
@ -889,14 +900,16 @@ static int encode_residual(FlacEncodeContext *ctx, int ch)
sub->type = FLAC_SUBFRAME_LPC;
sub->type_code = sub->type | (sub->order-1);
sub->shift = shift[sub->order-1];
for(i=0; i<sub->order; i++) {
for (i = 0; i < sub->order; i++)
sub->coefs[i] = coefs[sub->order-1][i];
}
encode_residual_lpc(res, smp, n, sub->order, sub->coefs, sub->shift);
return calc_rice_params_lpc(&sub->rc, min_porder, max_porder, res, n, sub->order,
sub->obits, precision);
return calc_rice_params_lpc(&sub->rc, min_porder, max_porder, res, n,
sub->order, sub->obits, precision);
}
static int encode_residual_v(FlacEncodeContext *ctx, int ch)
{
int i, n;
@ -911,9 +924,9 @@ static int encode_residual_v(FlacEncodeContext *ctx, int ch)
n = frame->blocksize;
/* CONSTANT */
for(i=1; i<n; i++) {
if(smp[i] != smp[0]) break;
}
for (i = 1; i < n; i++)
if (smp[i] != smp[0])
break;
if (i == n) {
sub->type = sub->type_code = FLAC_SUBFRAME_CONSTANT;
res[0] = smp[0];
@ -926,6 +939,7 @@ static int encode_residual_v(FlacEncodeContext *ctx, int ch)
return sub->obits * n;
}
static int estimate_stereo_mode(int32_t *left_ch, int32_t *right_ch, int n)
{
int i, best;
@ -958,11 +972,9 @@ static int estimate_stereo_mode(int32_t *left_ch, int32_t *right_ch, int n)
/* return mode with lowest score */
best = 0;
for(i=1; i<4; i++) {
if(score[i] < score[best]) {
for (i = 1; i < 4; i++)
if (score[i] < score[best])
best = i;
}
}
if (best == 0) {
return FLAC_CHMODE_INDEPENDENT;
} else if (best == 1) {
@ -974,8 +986,9 @@ static int estimate_stereo_mode(int32_t *left_ch, int32_t *right_ch, int n)
}
}
/**
* Perform stereo channel decorrelation
* Perform stereo channel decorrelation.
*/
static void channel_decorrelation(FlacEncodeContext *ctx)
{
@ -996,9 +1009,8 @@ static void channel_decorrelation(FlacEncodeContext *ctx)
frame->ch_mode = estimate_stereo_mode(left, right, n);
/* perform decorrelation and adjust bits-per-sample */
if(frame->ch_mode == FLAC_CHMODE_INDEPENDENT) {
if (frame->ch_mode == FLAC_CHMODE_INDEPENDENT)
return;
}
if (frame->ch_mode == FLAC_CHMODE_MID_SIDE) {
int32_t tmp;
for (i = 0; i < n; i++) {
@ -1008,24 +1020,24 @@ static void channel_decorrelation(FlacEncodeContext *ctx)
}
frame->subframes[1].obits++;
} else if (frame->ch_mode == FLAC_CHMODE_LEFT_SIDE) {
for(i=0; i<n; i++) {
for (i = 0; i < n; i++)
right[i] = left[i] - right[i];
}
frame->subframes[1].obits++;
} else {
for(i=0; i<n; i++) {
for (i = 0; i < n; i++)
left[i] -= right[i];
}
frame->subframes[0].obits++;
}
}
static void write_utf8(PutBitContext *pb, uint32_t val)
{
uint8_t tmp;
PUT_UTF8(val, tmp, put_bits(pb, 8, tmp);)
}
static void output_frame_header(FlacEncodeContext *s)
{
FlacFrame *frame;
@ -1036,30 +1048,33 @@ static void output_frame_header(FlacEncodeContext *s)
put_bits(&s->pb, 16, 0xFFF8);
put_bits(&s->pb, 4, frame->bs_code[0]);
put_bits(&s->pb, 4, s->sr_code[0]);
if(frame->ch_mode == FLAC_CHMODE_INDEPENDENT) {
if (frame->ch_mode == FLAC_CHMODE_INDEPENDENT)
put_bits(&s->pb, 4, s->channels-1);
} else {
else
put_bits(&s->pb, 4, frame->ch_mode);
}
put_bits(&s->pb, 3, 4); /* bits-per-sample code */
put_bits(&s->pb, 1, 0);
write_utf8(&s->pb, s->frame_count);
if(frame->bs_code[0] == 6) {
if (frame->bs_code[0] == 6)
put_bits(&s->pb, 8, frame->bs_code[1]);
} else if(frame->bs_code[0] == 7) {
else if (frame->bs_code[0] == 7)
put_bits(&s->pb, 16, frame->bs_code[1]);
}
if(s->sr_code[0] == 12) {
if (s->sr_code[0] == 12)
put_bits(&s->pb, 8, s->sr_code[1]);
} else if(s->sr_code[0] > 12) {
else if (s->sr_code[0] > 12)
put_bits(&s->pb, 16, s->sr_code[1]);
}
flush_put_bits(&s->pb);
crc = av_crc(av_crc_get_table(AV_CRC_8_ATM), 0,
s->pb.buf, put_bits_count(&s->pb)>>3);
crc = av_crc(av_crc_get_table(AV_CRC_8_ATM), 0, s->pb.buf,
put_bits_count(&s->pb) >> 3);
put_bits(&s->pb, 8, crc);
}
static void output_subframe_constant(FlacEncodeContext *s, int ch)
{
FlacSubframe *sub;
@ -1070,6 +1085,7 @@ static void output_subframe_constant(FlacEncodeContext *s, int ch)
put_sbits(&s->pb, sub->obits, res);
}
static void output_subframe_verbatim(FlacEncodeContext *s, int ch)
{
int i;
@ -1086,6 +1102,7 @@ static void output_subframe_verbatim(FlacEncodeContext *s, int ch)
}
}
static void output_residual(FlacEncodeContext *ctx, int ch)
{
int i, j, p, n, parts;
@ -1114,12 +1131,13 @@ static void output_residual(FlacEncodeContext *ctx, int ch)
for (p = 0; p < parts; p++) {
k = sub->rc.params[p];
put_bits(&ctx->pb, 4, k);
if(p == 1) res_cnt = psize;
for(i=0; i<res_cnt && j<n; i++, j++) {
if (p == 1)
res_cnt = psize;
for (i = 0; i < res_cnt && j < n; i++, j++)
set_sr_golomb_flac(&ctx->pb, res[j], k, INT32_MAX, 0);
}
}
}
static void output_subframe_fixed(FlacEncodeContext *ctx, int ch)
{
@ -1131,14 +1149,14 @@ static void output_subframe_fixed(FlacEncodeContext *ctx, int ch)
sub = &frame->subframes[ch];
/* warm-up samples */
for(i=0; i<sub->order; i++) {
for (i = 0; i < sub->order; i++)
put_sbits(&ctx->pb, sub->obits, sub->residual[i]);
}
/* residual */
output_residual(ctx, ch);
}
static void output_subframe_lpc(FlacEncodeContext *ctx, int ch)
{
int i, cbits;
@ -1149,22 +1167,21 @@ static void output_subframe_lpc(FlacEncodeContext *ctx, int ch)
sub = &frame->subframes[ch];
/* warm-up samples */
for(i=0; i<sub->order; i++) {
for (i = 0; i < sub->order; i++)
put_sbits(&ctx->pb, sub->obits, sub->residual[i]);
}
/* LPC coefficients */
cbits = ctx->options.lpc_coeff_precision;
put_bits( &ctx->pb, 4, cbits-1);
put_sbits(&ctx->pb, 5, sub->shift);
for(i=0; i<sub->order; i++) {
for (i = 0; i < sub->order; i++)
put_sbits(&ctx->pb, cbits, sub->coefs[i]);
}
/* residual */
output_residual(ctx, ch);
}
static void output_subframes(FlacEncodeContext *s)
{
FlacFrame *frame;
@ -1182,28 +1199,29 @@ static void output_subframes(FlacEncodeContext *s)
put_bits(&s->pb, 1, 0); /* no wasted bits */
/* subframe */
if(sub->type == FLAC_SUBFRAME_CONSTANT) {
if(sub->type == FLAC_SUBFRAME_CONSTANT)
output_subframe_constant(s, ch);
} else if(sub->type == FLAC_SUBFRAME_VERBATIM) {
else if(sub->type == FLAC_SUBFRAME_VERBATIM)
output_subframe_verbatim(s, ch);
} else if(sub->type == FLAC_SUBFRAME_FIXED) {
else if(sub->type == FLAC_SUBFRAME_FIXED)
output_subframe_fixed(s, ch);
} else if(sub->type == FLAC_SUBFRAME_LPC) {
else if(sub->type == FLAC_SUBFRAME_LPC)
output_subframe_lpc(s, ch);
}
}
}
static void output_frame_footer(FlacEncodeContext *s)
{
int crc;
flush_put_bits(&s->pb);
crc = av_bswap16(av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0,
s->pb.buf, put_bits_count(&s->pb)>>3));
crc = av_bswap16(av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, s->pb.buf,
put_bits_count(&s->pb)>>3));
put_bits(&s->pb, 16, crc);
flush_put_bits(&s->pb);
}
static void update_md5_sum(FlacEncodeContext *s, const int16_t *samples)
{
#if HAVE_BIGENDIAN
@ -1217,6 +1235,7 @@ static void update_md5_sum(FlacEncodeContext *s, const int16_t *samples)
#endif
}
static int flac_encode_frame(AVCodecContext *avctx, uint8_t *frame,
int buf_size, void *data)
{
@ -1247,9 +1266,8 @@ static int flac_encode_frame(AVCodecContext *avctx, uint8_t *frame,
channel_decorrelation(s);
for(ch=0; ch<s->channels; ch++) {
for (ch = 0; ch < s->channels; ch++)
encode_residual(s, ch);
}
write_frame:
init_put_bits(&s->pb, frame, buf_size);
@ -1266,9 +1284,8 @@ write_frame:
}
/* frame too large. use verbatim mode */
for(ch=0; ch<s->channels; ch++) {
for (ch = 0; ch < s->channels; ch++)
encode_residual_v(s, ch);
}
reencoded = 1;
goto write_frame;
}
@ -1284,6 +1301,7 @@ write_frame:
return out_bytes;
}
static av_cold int flac_encode_close(AVCodecContext *avctx)
{
if (avctx->priv_data) {
@ -1296,6 +1314,7 @@ static av_cold int flac_encode_close(AVCodecContext *avctx)
return 0;
}
AVCodec flac_encoder = {
"flac",
AVMEDIA_TYPE_AUDIO,

Write Preview
Loading…
Cancel
Save