static int transcode_audio(InputStream *ist, AVPacket *pkt, int *got_output)

{

    AVFrame *decoded_frame;

    AVCodecContext *avctx = ist->st->codec;

    int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);

    int i, ret;



    if (!ist->decoded_frame && !(ist->decoded_frame = avcodec_alloc_frame()))

        return AVERROR(ENOMEM);

    else

        avcodec_get_frame_defaults(ist->decoded_frame);

    decoded_frame = ist->decoded_frame;



    ret = avcodec_decode_audio4(avctx, decoded_frame, got_output, pkt);

    if (ret < 0) {

        return ret;

    }



    if (!*got_output) {

        /* no audio frame */

        return ret;

    }



    /* if the decoder provides a pts, use it instead of the last packet pts.

       the decoder could be delaying output by a packet or more. */

    if (decoded_frame->pts != AV_NOPTS_VALUE)

        ist->next_dts = decoded_frame->pts;



    /* increment next_dts to use for the case where the input stream does not

       have timestamps or there are multiple frames in the packet */

    ist->next_dts += ((int64_t)AV_TIME_BASE * decoded_frame->nb_samples) /

                     avctx->sample_rate;



    // preprocess audio (volume)

    if (audio_volume != 256) {

        int decoded_data_size = decoded_frame->nb_samples * avctx->channels * bps;

        void *samples = decoded_frame->data[0];

        switch (avctx->sample_fmt) {

        case AV_SAMPLE_FMT_U8:

        {

            uint8_t *volp = samples;

            for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {

                int v = (((*volp - 128) * audio_volume + 128) >> 8) + 128;

                *volp++ = av_clip_uint8(v);

            }

            break;

        }

        case AV_SAMPLE_FMT_S16:

        {

            int16_t *volp = samples;

            for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {

                int v = ((*volp) * audio_volume + 128) >> 8;

                *volp++ = av_clip_int16(v);

            }

            break;

        }

        case AV_SAMPLE_FMT_S32:

        {

            int32_t *volp = samples;

            for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {

                int64_t v = (((int64_t)*volp * audio_volume + 128) >> 8);

                *volp++ = av_clipl_int32(v);

            }

            break;

        }

        case AV_SAMPLE_FMT_FLT:

        {

            float *volp = samples;

            float scale = audio_volume / 256.f;

            for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {

                *volp++ *= scale;

            }

            break;

        }

        case AV_SAMPLE_FMT_DBL:

        {

            double *volp = samples;

            double scale = audio_volume / 256.;

            for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {

                *volp++ *= scale;

            }

            break;

        }

        default:

            av_log(NULL, AV_LOG_FATAL,

                   "Audio volume adjustment on sample format %s is not supported.\n",

                   av_get_sample_fmt_name(ist->st->codec->sample_fmt));

            exit_program(1);

        }

    }



    rate_emu_sleep(ist);



    for (i = 0; i < nb_output_streams; i++) {

        OutputStream *ost = output_streams[i];



        if (!check_output_constraints(ist, ost) || !ost->encoding_needed)

            continue;

        do_audio_out(output_files[ost->file_index]->ctx, ost, ist, decoded_frame);

    }



    return ret;

}

static int transcode_audio(InputStream *ist, AVPacket *pkt, int *got_output)

{

    AVFrame *decoded_frame;

    AVCodecContext *avctx = ist->st->codec;

    int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);

    int i, ret;



    if (!ist->decoded_frame && !(ist->decoded_frame = avcodec_alloc_frame()))

        return AVERROR(ENOMEM);

    else

        avcodec_get_frame_defaults(ist->decoded_frame);

    decoded_frame = ist->decoded_frame;



    ret = avcodec_decode_audio4(avctx, decoded_frame, got_output, pkt);

    if (ret < 0) {

        return ret;

    }



    if (!*got_output) {

        

        return ret;

    }



    



    if (decoded_frame->pts != AV_NOPTS_VALUE)

        ist->next_dts = decoded_frame->pts;



    



    ist->next_dts += ((int64_t)AV_TIME_BASE * decoded_frame->nb_samples) /

                     avctx->sample_rate;



    

    if (audio_volume != 256) {

        int decoded_data_size = decoded_frame->nb_samples * avctx->channels * bps;

        void *samples = decoded_frame->data[0];

        switch (avctx->sample_fmt) {

        case AV_SAMPLE_FMT_U8:

        {

            uint8_t *volp = samples;

            for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {

                int v = (((*volp - 128) * audio_volume + 128) >> 8) + 128;

                *volp++ = av_clip_uint8(v);

            }

            break;

        }

        case AV_SAMPLE_FMT_S16:

        {

            int16_t *volp = samples;

            for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {

                int v = ((*volp) * audio_volume + 128) >> 8;

                *volp++ = av_clip_int16(v);

            }

            break;

        }

        case AV_SAMPLE_FMT_S32:

        {

            int32_t *volp = samples;

            for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {

                int64_t v = (((int64_t)*volp * audio_volume + 128) >> 8);

                *volp++ = av_clipl_int32(v);

            }

            break;

        }

        case AV_SAMPLE_FMT_FLT:

        {

            float *volp = samples;

            float scale = audio_volume / 256.f;

            for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {

                *volp++ *= scale;

            }

            break;

        }

        case AV_SAMPLE_FMT_DBL:

        {

            double *volp = samples;

            double scale = audio_volume / 256.;

            for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {

                *volp++ *= scale;

            }

            break;

        }

        default:

            av_log(NULL, AV_LOG_FATAL,

                   "Audio volume adjustment on sample format %s is not supported.\n",

                   av_get_sample_fmt_name(ist->st->codec->sample_fmt));

            exit_program(1);

        }

    }



    rate_emu_sleep(ist);



    for (i = 0; i < nb_output_streams; i++) {

        OutputStream *ost = output_streams[i];



        if (!check_output_constraints(ist, ost) || !ost->encoding_needed)

            continue;

        do_audio_out(output_files[ost->file_index]->ctx, ost, ist, decoded_frame);

    }



    return ret;

}

            exit_program(1);             exit_program(1);             exit_program(1);         return AVERROR(ENOMEM);             exit_program(1);     int i, ret;     ist->next_dts += ((int64_t)AV_TIME_BASE * decoded_frame->nb_samples) /                      avctx->sample_rate;     for (i = 0; i < nb_output_streams; i++) {         OutputStream *ost = output_streams[i];         if (!check_output_constraints(ist, ost) || !ost->encoding_needed)             continue;         do_audio_out(output_files[ost->file_index]->ctx, ost, ist, decoded_frame);
static int FUNC_0(InputStream *VAR_0, AVPacket *VAR_1, int *VAR_2)

{

    AVFrame *decoded_frame;

    AVCodecContext *avctx = VAR_0->st->codec;

    int VAR_3 = av_get_bytes_per_sample(VAR_0->st->codec->sample_fmt);

    int VAR_4, VAR_5;



    if (!VAR_0->decoded_frame && !(VAR_0->decoded_frame = avcodec_alloc_frame()))

        return AVERROR(ENOMEM);

    else

        avcodec_get_frame_defaults(VAR_0->decoded_frame);

    decoded_frame = VAR_0->decoded_frame;



    VAR_5 = avcodec_decode_audio4(avctx, decoded_frame, VAR_2, VAR_1);

    if (VAR_5 < 0) {

        return VAR_5;

    }



    if (!*VAR_2) {

        

        return VAR_5;

    }



    



    if (decoded_frame->pts != AV_NOPTS_VALUE)

        VAR_0->next_dts = decoded_frame->pts;



    



    VAR_0->next_dts += ((int64_t)AV_TIME_BASE * decoded_frame->nb_samples) /

                     avctx->sample_rate;



    

    if (audio_volume != 256) {

        int VAR_6 = decoded_frame->nb_samples * avctx->channels * VAR_3;

        void *VAR_7 = decoded_frame->data[0];

        switch (avctx->sample_fmt) {

        case AV_SAMPLE_FMT_U8:

        {

            uint8_t *VAR_10 = VAR_7;

            for (VAR_4 = 0; VAR_4 < (VAR_6 / sizeof(*VAR_10)); VAR_4++) {

                int v = (((*VAR_10 - 128) * audio_volume + 128) >> 8) + 128;

                *VAR_10++ = av_clip_uint8(v);

            }

            break;

        }

        case AV_SAMPLE_FMT_S16:

        {

            int16_t *VAR_10 = VAR_7;

            for (VAR_4 = 0; VAR_4 < (VAR_6 / sizeof(*VAR_10)); VAR_4++) {

                int v = ((*VAR_10) * audio_volume + 128) >> 8;

                *VAR_10++ = av_clip_int16(v);

            }

            break;

        }

        case AV_SAMPLE_FMT_S32:

        {

            int32_t *VAR_10 = VAR_7;

            for (VAR_4 = 0; VAR_4 < (VAR_6 / sizeof(*VAR_10)); VAR_4++) {

                int64_t v = (((int64_t)*VAR_10 * audio_volume + 128) >> 8);

                *VAR_10++ = av_clipl_int32(v);

            }

            break;

        }

        case AV_SAMPLE_FMT_FLT:

        {

            float *VAR_10 = VAR_7;

            float VAR_10 = audio_volume / 256.f;

            for (VAR_4 = 0; VAR_4 < (VAR_6 / sizeof(*VAR_10)); VAR_4++) {

                *VAR_10++ *= VAR_10;

            }

            break;

        }

        case AV_SAMPLE_FMT_DBL:

        {

            double *VAR_10 = VAR_7;

            double VAR_10 = audio_volume / 256.;

            for (VAR_4 = 0; VAR_4 < (VAR_6 / sizeof(*VAR_10)); VAR_4++) {

                *VAR_10++ *= VAR_10;

            }

            break;

        }

        default:

            av_log(NULL, AV_LOG_FATAL,

                   "Audio volume adjustment on sample format %s is not supported.\n",

                   av_get_sample_fmt_name(VAR_0->st->codec->sample_fmt));

            exit_program(1);

        }

    }



    rate_emu_sleep(VAR_0);



    for (VAR_4 = 0; VAR_4 < nb_output_streams; VAR_4++) {

        OutputStream *ost = output_streams[VAR_4];



        if (!check_output_constraints(VAR_0, ost) || !ost->encoding_needed)

            continue;

        do_audio_out(output_files[ost->file_index]->ctx, ost, VAR_0, decoded_frame);

    }



    return VAR_5;

}

static int FUNC_0(InputStream *VAR_0, AVPacket *VAR_1, int *VAR_2)
{ AVFrame *decoded_frame; AVCodecContext *avctx = VAR_0->st->codec; int VAR_3 = av_get_bytes_per_sample(VAR_0->st->codec->sample_fmt); int VAR_4, VAR_5; if (!VAR_0->decoded_frame && !(VAR_0->decoded_frame = avcodec_alloc_frame()))
return AVERROR(ENOMEM); else
avcodec_get_frame_defaults(VAR_0->decoded_frame); decoded_frame = VAR_0->decoded_frame; VAR_5 = avcodec_decode_audio4(avctx, decoded_frame, VAR_2, VAR_1); if (VAR_5 < 0) { return VAR_5; } if (!*VAR_2) { return VAR_5; } if (decoded_frame->pts != AV_NOPTS_VALUE)
VAR_0->next_dts = decoded_frame->pts; VAR_0->next_dts += ((int64_t)AV_TIME_BASE * decoded_frame->nb_samples) /
avctx->sample_rate; if (audio_volume != 256) { int VAR_6 = decoded_frame->nb_samples * avctx->channels * VAR_3; void *VAR_7 = decoded_frame->data[0]; switch (avctx->sample_fmt) { case AV_SAMPLE_FMT_U8:
{ uint8_t *VAR_10 = VAR_7; for (VAR_4 = 0; VAR_4 < (VAR_6 / sizeof(*VAR_10)); VAR_4++) { int v = (((*VAR_10 - 128) * audio_volume + 128) >> 8) + 128; *VAR_10++ = av_clip_uint8(v); } break; } case AV_SAMPLE_FMT_S16:
{ int16_t *VAR_10 = VAR_7; for (VAR_4 = 0; VAR_4 < (VAR_6 / sizeof(*VAR_10)); VAR_4++) { int v = ((*VAR_10) * audio_volume + 128) >> 8; *VAR_10++ = av_clip_int16(v); } break; } case AV_SAMPLE_FMT_S32:
{ int32_t *VAR_10 = VAR_7; for (VAR_4 = 0; VAR_4 < (VAR_6 / sizeof(*VAR_10)); VAR_4++) { int64_t v = (((int64_t)*VAR_10 * audio_volume + 128) >> 8); *VAR_10++ = av_clipl_int32(v); } break; } case AV_SAMPLE_FMT_FLT:
{ float *VAR_10 = VAR_7; float VAR_10 = audio_volume / 256.f; for (VAR_4 = 0; VAR_4 < (VAR_6 / sizeof(*VAR_10)); VAR_4++) { *VAR_10++ *= VAR_10; } break; } case AV_SAMPLE_FMT_DBL:
{ double *VAR_10 = VAR_7; double VAR_10 = audio_volume / 256.; for (VAR_4 = 0; VAR_4 < (VAR_6 / sizeof(*VAR_10)); VAR_4++) { *VAR_10++ *= VAR_10; } break; } default:
av_log(NULL, AV_LOG_FATAL,
"Audio volume adjustment on sample format %s is not supported.\n",
av_get_sample_fmt_name(VAR_0->st->codec->sample_fmt)); exit_program(1); } } rate_emu_sleep(VAR_0); for (VAR_4 = 0; VAR_4 < nb_output_streams; VAR_4++) { OutputStream *ost = output_streams[VAR_4]; if (!check_output_constraints(VAR_0, ost) || !ost->encoding_needed)
continue; do_audio_out(output_files[ost->file_index]->ctx, ost, VAR_0, decoded_frame); } return VAR_5; }