X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=libavcodec%2Flibvorbis.c;h=f7ea253c4f068183c209c0858dfe33d83f05696c;hb=453642f8afe9f979fcc813a246b1ec656ec36a93;hp=d7839425eaa4fb6fca15448469e36a9bf78f4b48;hpb=f15c4281dcabeddb61cb6430e0cc1047173292f8;p=ffmpeg diff --git a/libavcodec/libvorbis.c b/libavcodec/libvorbis.c index d7839425eaa..f7ea253c4f0 100644 --- a/libavcodec/libvorbis.c +++ b/libavcodec/libvorbis.c @@ -26,11 +26,14 @@ #include +#include "libavutil/fifo.h" #include "libavutil/opt.h" #include "avcodec.h" +#include "audio_frame_queue.h" #include "bytestream.h" #include "internal.h" #include "vorbis.h" +#include "vorbis_parser.h" #undef NDEBUG #include @@ -40,26 +43,27 @@ * an output packet will always start at the same point as one of the input * packets. */ -#define OGGVORBIS_FRAME_SIZE 64 +#define LIBVORBIS_FRAME_SIZE 64 #define BUFFER_SIZE (1024 * 64) -typedef struct OggVorbisContext { +typedef struct LibvorbisContext { AVClass *av_class; /**< class for AVOptions */ vorbis_info vi; /**< vorbis_info used during init */ vorbis_dsp_state vd; /**< DSP state used for analysis */ vorbis_block vb; /**< vorbis_block used for analysis */ - uint8_t buffer[BUFFER_SIZE]; /**< output packet buffer */ - int buffer_index; /**< current buffer position */ + AVFifoBuffer *pkt_fifo; /**< output packet buffer */ int eof; /**< end-of-file flag */ int dsp_initialized; /**< vd has been initialized */ vorbis_comment vc; /**< VorbisComment info */ ogg_packet op; /**< ogg packet */ double iblock; /**< impulse block bias option */ -} OggVorbisContext; + AVVorbisParseContext *vp; /**< parse context to get durations */ + AudioFrameQueue afq; /**< frame queue for timestamps */ +} LibvorbisContext; static const AVOption options[] = { - { "iblock", "Sets the impulse block bias", offsetof(OggVorbisContext, iblock), AV_OPT_TYPE_DOUBLE, { .dbl = 0 }, -15, 0, AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM }, + { "iblock", "Sets the impulse block bias", offsetof(LibvorbisContext, iblock), AV_OPT_TYPE_DOUBLE, { .dbl = 0 }, -15, 0, AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM }, { NULL } }; @@ -81,10 +85,9 @@ static int vorbis_error_to_averror(int ov_err) } } -static av_cold int oggvorbis_init_encoder(vorbis_info *vi, - AVCodecContext *avctx) +static av_cold int libvorbis_setup(vorbis_info *vi, AVCodecContext *avctx) { - OggVorbisContext *s = avctx->priv_data; + LibvorbisContext *s = avctx->priv_data; double cfreq; int ret; @@ -144,9 +147,9 @@ static int xiph_len(int l) return 1 + l / 255 + l; } -static av_cold int oggvorbis_encode_close(AVCodecContext *avctx) +static av_cold int libvorbis_encode_close(AVCodecContext *avctx) { - OggVorbisContext *s = avctx->priv_data; + LibvorbisContext *s = avctx->priv_data; /* notify vorbisenc this is EOF */ if (s->dsp_initialized) @@ -156,31 +159,36 @@ static av_cold int oggvorbis_encode_close(AVCodecContext *avctx) vorbis_dsp_clear(&s->vd); vorbis_info_clear(&s->vi); - av_freep(&avctx->coded_frame); + av_fifo_free(s->pkt_fifo); + ff_af_queue_close(&s->afq); av_freep(&avctx->extradata); + av_vorbis_parse_free(&s->vp); + return 0; } -static av_cold int oggvorbis_encode_init(AVCodecContext *avctx) +static av_cold int libvorbis_encode_init(AVCodecContext *avctx) { - OggVorbisContext *s = avctx->priv_data; + LibvorbisContext *s = avctx->priv_data; ogg_packet header, header_comm, header_code; uint8_t *p; unsigned int offset; int ret; vorbis_info_init(&s->vi); - if ((ret = oggvorbis_init_encoder(&s->vi, avctx))) { - av_log(avctx, AV_LOG_ERROR, "oggvorbis_encode_init: init_encoder failed\n"); + if ((ret = libvorbis_setup(&s->vi, avctx))) { + av_log(avctx, AV_LOG_ERROR, "encoder setup failed\n"); goto error; } if ((ret = vorbis_analysis_init(&s->vd, &s->vi))) { + av_log(avctx, AV_LOG_ERROR, "analysis init failed\n"); ret = vorbis_error_to_averror(ret); goto error; } s->dsp_initialized = 1; if ((ret = vorbis_block_init(&s->vd, &s->vb))) { + av_log(avctx, AV_LOG_ERROR, "dsp init failed\n"); ret = vorbis_error_to_averror(ret); goto error; } @@ -215,109 +223,132 @@ static av_cold int oggvorbis_encode_init(AVCodecContext *avctx) offset += header_code.bytes; assert(offset == avctx->extradata_size); + s->vp = av_vorbis_parse_init(avctx->extradata, avctx->extradata_size); + if (!s->vp) { + av_log(avctx, AV_LOG_ERROR, "invalid extradata\n"); + return ret; + } + vorbis_comment_clear(&s->vc); - avctx->frame_size = OGGVORBIS_FRAME_SIZE; + avctx->frame_size = LIBVORBIS_FRAME_SIZE; + ff_af_queue_init(avctx, &s->afq); - avctx->coded_frame = avcodec_alloc_frame(); - if (!avctx->coded_frame) { + s->pkt_fifo = av_fifo_alloc(BUFFER_SIZE); + if (!s->pkt_fifo) { ret = AVERROR(ENOMEM); goto error; } return 0; error: - oggvorbis_encode_close(avctx); + libvorbis_encode_close(avctx); return ret; } -static int oggvorbis_encode_frame(AVCodecContext *avctx, unsigned char *packets, - int buf_size, void *data) +static int libvorbis_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, + const AVFrame *frame, int *got_packet_ptr) { - OggVorbisContext *s = avctx->priv_data; + LibvorbisContext *s = avctx->priv_data; ogg_packet op; - signed short *audio = data; - int pkt_size; + int ret, duration; /* send samples to libvorbis */ - if (data) { - const int samples = avctx->frame_size; + if (frame) { + const int samples = frame->nb_samples; float **buffer; int c, channels = s->vi.channels; buffer = vorbis_analysis_buffer(&s->vd, samples); for (c = 0; c < channels; c++) { - int i; int co = (channels > 8) ? c : ff_vorbis_encoding_channel_layout_offsets[channels - 1][c]; - for (i = 0; i < samples; i++) - buffer[c][i] = audio[i * channels + co] / 32768.f; + memcpy(buffer[c], frame->extended_data[co], + samples * sizeof(*buffer[c])); + } + if ((ret = vorbis_analysis_wrote(&s->vd, samples)) < 0) { + av_log(avctx, AV_LOG_ERROR, "error in vorbis_analysis_wrote()\n"); + return vorbis_error_to_averror(ret); } - vorbis_analysis_wrote(&s->vd, samples); + if ((ret = ff_af_queue_add(&s->afq, frame)) < 0) + return ret; } else { if (!s->eof) - vorbis_analysis_wrote(&s->vd, 0); + if ((ret = vorbis_analysis_wrote(&s->vd, 0)) < 0) { + av_log(avctx, AV_LOG_ERROR, "error in vorbis_analysis_wrote()\n"); + return vorbis_error_to_averror(ret); + } s->eof = 1; } /* retrieve available packets from libvorbis */ - while (vorbis_analysis_blockout(&s->vd, &s->vb) == 1) { - vorbis_analysis(&s->vb, NULL); - vorbis_bitrate_addblock(&s->vb); + while ((ret = vorbis_analysis_blockout(&s->vd, &s->vb)) == 1) { + if ((ret = vorbis_analysis(&s->vb, NULL)) < 0) + break; + if ((ret = vorbis_bitrate_addblock(&s->vb)) < 0) + break; /* add any available packets to the output packet buffer */ - while (vorbis_bitrate_flushpacket(&s->vd, &op)) { - /* i'd love to say the following line is a hack, but sadly it's - * not, apparently the end of stream decision is in libogg. */ - if (op.bytes == 1 && op.e_o_s) - continue; - if (s->buffer_index + sizeof(ogg_packet) + op.bytes > BUFFER_SIZE) { - av_log(avctx, AV_LOG_ERROR, "libvorbis: buffer overflow."); - return -1; + while ((ret = vorbis_bitrate_flushpacket(&s->vd, &op)) == 1) { + if (av_fifo_space(s->pkt_fifo) < sizeof(ogg_packet) + op.bytes) { + av_log(avctx, AV_LOG_ERROR, "packet buffer is too small"); + return AVERROR_BUG; } - memcpy(s->buffer + s->buffer_index, &op, sizeof(ogg_packet)); - s->buffer_index += sizeof(ogg_packet); - memcpy(s->buffer + s->buffer_index, op.packet, op.bytes); - s->buffer_index += op.bytes; + av_fifo_generic_write(s->pkt_fifo, &op, sizeof(ogg_packet), NULL); + av_fifo_generic_write(s->pkt_fifo, op.packet, op.bytes, NULL); + } + if (ret < 0) { + av_log(avctx, AV_LOG_ERROR, "error getting available packets\n"); + break; } } + if (ret < 0) { + av_log(avctx, AV_LOG_ERROR, "error getting available packets\n"); + return vorbis_error_to_averror(ret); + } - /* output then next packet from the output buffer, if available */ - pkt_size = 0; - if (s->buffer_index) { - ogg_packet *op2 = (ogg_packet *)s->buffer; - op2->packet = s->buffer + sizeof(ogg_packet); - - pkt_size = op2->bytes; - // FIXME: we should use the user-supplied pts and duration - avctx->coded_frame->pts = ff_samples_to_time_base(avctx, - op2->granulepos); - if (pkt_size > buf_size) { - av_log(avctx, AV_LOG_ERROR, "libvorbis: buffer overflow."); - return -1; - } + /* check for available packets */ + if (av_fifo_size(s->pkt_fifo) < sizeof(ogg_packet)) + return 0; + + av_fifo_generic_read(s->pkt_fifo, &op, sizeof(ogg_packet), NULL); - memcpy(packets, op2->packet, pkt_size); - s->buffer_index -= pkt_size + sizeof(ogg_packet); - memmove(s->buffer, s->buffer + pkt_size + sizeof(ogg_packet), - s->buffer_index); + if ((ret = ff_alloc_packet(avpkt, op.bytes))) { + av_log(avctx, AV_LOG_ERROR, "Error getting output packet\n"); + return ret; + } + av_fifo_generic_read(s->pkt_fifo, avpkt->data, op.bytes, NULL); + + avpkt->pts = ff_samples_to_time_base(avctx, op.granulepos); + + duration = av_vorbis_parse_frame(s->vp, avpkt->data, avpkt->size); + if (duration > 0) { + /* we do not know encoder delay until we get the first packet from + * libvorbis, so we have to update the AudioFrameQueue counts */ + if (!avctx->initial_padding) { + avctx->initial_padding = duration; + s->afq.remaining_delay += duration; + s->afq.remaining_samples += duration; + } + ff_af_queue_remove(&s->afq, duration, &avpkt->pts, &avpkt->duration); } - return pkt_size; + *got_packet_ptr = 1; + return 0; } AVCodec ff_libvorbis_encoder = { .name = "libvorbis", + .long_name = NULL_IF_CONFIG_SMALL("libvorbis Vorbis"), .type = AVMEDIA_TYPE_AUDIO, - .id = CODEC_ID_VORBIS, - .priv_data_size = sizeof(OggVorbisContext), - .init = oggvorbis_encode_init, - .encode = oggvorbis_encode_frame, - .close = oggvorbis_encode_close, + .id = AV_CODEC_ID_VORBIS, + .priv_data_size = sizeof(LibvorbisContext), + .init = libvorbis_encode_init, + .encode2 = libvorbis_encode_frame, + .close = libvorbis_encode_close, .capabilities = CODEC_CAP_DELAY, - .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16, + .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP, AV_SAMPLE_FMT_NONE }, - .long_name = NULL_IF_CONFIG_SMALL("libvorbis Vorbis"), .priv_class = &class, .defaults = defaults, };