Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | RSS feed

  1. /*
  2.  * Copyright (c) 2002 Mark Hills <mark@pogo.org.uk>
  3.  *
  4.  * This file is part of FFmpeg.
  5.  *
  6.  * FFmpeg is free software; you can redistribute it and/or
  7.  * modify it under the terms of the GNU Lesser General Public
  8.  * License as published by the Free Software Foundation; either
  9.  * version 2.1 of the License, or (at your option) any later version.
  10.  *
  11.  * FFmpeg is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14.  * Lesser General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU Lesser General Public
  17.  * License along with FFmpeg; if not, write to the Free Software
  18.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  19.  */
  20.  
  21. #include <vorbis/vorbisenc.h>
  22.  
  23. #include "libavutil/avassert.h"
  24. #include "libavutil/fifo.h"
  25. #include "libavutil/opt.h"
  26. #include "avcodec.h"
  27. #include "audio_frame_queue.h"
  28. #include "internal.h"
  29. #include "vorbis.h"
  30. #include "vorbis_parser.h"
  31.  
  32.  
  33. /* Number of samples the user should send in each call.
  34.  * This value is used because it is the LCD of all possible frame sizes, so
  35.  * an output packet will always start at the same point as one of the input
  36.  * packets.
  37.  */
  38. #define OGGVORBIS_FRAME_SIZE 64
  39.  
  40. #define BUFFER_SIZE (1024 * 64)
  41.  
  42. typedef struct OggVorbisEncContext {
  43.     AVClass *av_class;                  /**< class for AVOptions            */
  44.     AVFrame frame;
  45.     vorbis_info vi;                     /**< vorbis_info used during init   */
  46.     vorbis_dsp_state vd;                /**< DSP state used for analysis    */
  47.     vorbis_block vb;                    /**< vorbis_block used for analysis */
  48.     AVFifoBuffer *pkt_fifo;             /**< output packet buffer           */
  49.     int eof;                            /**< end-of-file flag               */
  50.     int dsp_initialized;                /**< vd has been initialized        */
  51.     vorbis_comment vc;                  /**< VorbisComment info             */
  52.     double iblock;                      /**< impulse block bias option      */
  53.     VorbisParseContext vp;              /**< parse context to get durations */
  54.     AudioFrameQueue afq;                /**< frame queue for timestamps     */
  55. } OggVorbisEncContext;
  56.  
  57. static const AVOption options[] = {
  58.     { "iblock", "Sets the impulse block bias", offsetof(OggVorbisEncContext, iblock), AV_OPT_TYPE_DOUBLE, { .dbl = 0 }, -15, 0, AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM },
  59.     { NULL }
  60. };
  61.  
  62. static const AVCodecDefault defaults[] = {
  63.     { "b",  "0" },
  64.     { NULL },
  65. };
  66.  
  67. static const AVClass vorbis_class = {
  68.     .class_name = "libvorbis",
  69.     .item_name  = av_default_item_name,
  70.     .option     = options,
  71.     .version    = LIBAVUTIL_VERSION_INT,
  72. };
  73.  
  74. static int vorbis_error_to_averror(int ov_err)
  75. {
  76.     switch (ov_err) {
  77.     case OV_EFAULT: return AVERROR_BUG;
  78.     case OV_EINVAL: return AVERROR(EINVAL);
  79.     case OV_EIMPL:  return AVERROR(EINVAL);
  80.     default:        return AVERROR_UNKNOWN;
  81.     }
  82. }
  83.  
  84. static av_cold int oggvorbis_init_encoder(vorbis_info *vi,
  85.                                           AVCodecContext *avctx)
  86. {
  87.     OggVorbisEncContext *s = avctx->priv_data;
  88.     double cfreq;
  89.     int ret;
  90.  
  91.     if (avctx->flags & CODEC_FLAG_QSCALE || !avctx->bit_rate) {
  92.         /* variable bitrate
  93.          * NOTE: we use the oggenc range of -1 to 10 for global_quality for
  94.          *       user convenience, but libvorbis uses -0.1 to 1.0.
  95.          */
  96.         float q = avctx->global_quality / (float)FF_QP2LAMBDA;
  97.         /* default to 3 if the user did not set quality or bitrate */
  98.         if (!(avctx->flags & CODEC_FLAG_QSCALE))
  99.             q = 3.0;
  100.         if ((ret = vorbis_encode_setup_vbr(vi, avctx->channels,
  101.                                            avctx->sample_rate,
  102.                                            q / 10.0)))
  103.             goto error;
  104.     } else {
  105.         int minrate = avctx->rc_min_rate > 0 ? avctx->rc_min_rate : -1;
  106.         int maxrate = avctx->rc_max_rate > 0 ? avctx->rc_max_rate : -1;
  107.  
  108.         /* average bitrate */
  109.         if ((ret = vorbis_encode_setup_managed(vi, avctx->channels,
  110.                                                avctx->sample_rate, maxrate,
  111.                                                avctx->bit_rate, minrate)))
  112.             goto error;
  113.  
  114.         /* variable bitrate by estimate, disable slow rate management */
  115.         if (minrate == -1 && maxrate == -1)
  116.             if ((ret = vorbis_encode_ctl(vi, OV_ECTL_RATEMANAGE2_SET, NULL)))
  117.                 goto error; /* should not happen */
  118.     }
  119.  
  120.     /* cutoff frequency */
  121.     if (avctx->cutoff > 0) {
  122.         cfreq = avctx->cutoff / 1000.0;
  123.         if ((ret = vorbis_encode_ctl(vi, OV_ECTL_LOWPASS_SET, &cfreq)))
  124.             goto error; /* should not happen */
  125.     }
  126.  
  127.     /* impulse block bias */
  128.     if (s->iblock) {
  129.         if ((ret = vorbis_encode_ctl(vi, OV_ECTL_IBLOCK_SET, &s->iblock)))
  130.             goto error;
  131.     }
  132.  
  133.     if (avctx->channels == 3 &&
  134.             avctx->channel_layout != (AV_CH_LAYOUT_STEREO|AV_CH_FRONT_CENTER) ||
  135.         avctx->channels == 4 &&
  136.             avctx->channel_layout != AV_CH_LAYOUT_2_2 &&
  137.             avctx->channel_layout != AV_CH_LAYOUT_QUAD ||
  138.         avctx->channels == 5 &&
  139.             avctx->channel_layout != AV_CH_LAYOUT_5POINT0 &&
  140.             avctx->channel_layout != AV_CH_LAYOUT_5POINT0_BACK ||
  141.         avctx->channels == 6 &&
  142.             avctx->channel_layout != AV_CH_LAYOUT_5POINT1 &&
  143.             avctx->channel_layout != AV_CH_LAYOUT_5POINT1_BACK ||
  144.         avctx->channels == 7 &&
  145.             avctx->channel_layout != (AV_CH_LAYOUT_5POINT1|AV_CH_BACK_CENTER) ||
  146.         avctx->channels == 8 &&
  147.             avctx->channel_layout != AV_CH_LAYOUT_7POINT1) {
  148.         if (avctx->channel_layout) {
  149.             char name[32];
  150.             av_get_channel_layout_string(name, sizeof(name), avctx->channels,
  151.                                          avctx->channel_layout);
  152.             av_log(avctx, AV_LOG_ERROR, "%s not supported by Vorbis: "
  153.                                              "output stream will have incorrect "
  154.                                              "channel layout.\n", name);
  155.         } else {
  156.             av_log(avctx, AV_LOG_WARNING, "No channel layout specified. The encoder "
  157.                                                "will use Vorbis channel layout for "
  158.                                                "%d channels.\n", avctx->channels);
  159.         }
  160.     }
  161.  
  162.     if ((ret = vorbis_encode_setup_init(vi)))
  163.         goto error;
  164.  
  165.     return 0;
  166. error:
  167.     return vorbis_error_to_averror(ret);
  168. }
  169.  
  170. /* How many bytes are needed for a buffer of length 'l' */
  171. static int xiph_len(int l)
  172. {
  173.     return 1 + l / 255 + l;
  174. }
  175.  
  176. static av_cold int oggvorbis_encode_close(AVCodecContext *avctx)
  177. {
  178.     OggVorbisEncContext *s = avctx->priv_data;
  179.  
  180.     /* notify vorbisenc this is EOF */
  181.     if (s->dsp_initialized)
  182.         vorbis_analysis_wrote(&s->vd, 0);
  183.  
  184.     vorbis_block_clear(&s->vb);
  185.     vorbis_dsp_clear(&s->vd);
  186.     vorbis_info_clear(&s->vi);
  187.  
  188.     av_fifo_free(s->pkt_fifo);
  189.     ff_af_queue_close(&s->afq);
  190.     av_freep(&avctx->extradata);
  191.  
  192.     return 0;
  193. }
  194.  
  195. static av_cold int oggvorbis_encode_init(AVCodecContext *avctx)
  196. {
  197.     OggVorbisEncContext *s = avctx->priv_data;
  198.     ogg_packet header, header_comm, header_code;
  199.     uint8_t *p;
  200.     unsigned int offset;
  201.     int ret;
  202.  
  203.     vorbis_info_init(&s->vi);
  204.     if ((ret = oggvorbis_init_encoder(&s->vi, avctx))) {
  205.         av_log(avctx, AV_LOG_ERROR, "encoder setup failed\n");
  206.         goto error;
  207.     }
  208.     if ((ret = vorbis_analysis_init(&s->vd, &s->vi))) {
  209.         av_log(avctx, AV_LOG_ERROR, "analysis init failed\n");
  210.         ret = vorbis_error_to_averror(ret);
  211.         goto error;
  212.     }
  213.     s->dsp_initialized = 1;
  214.     if ((ret = vorbis_block_init(&s->vd, &s->vb))) {
  215.         av_log(avctx, AV_LOG_ERROR, "dsp init failed\n");
  216.         ret = vorbis_error_to_averror(ret);
  217.         goto error;
  218.     }
  219.  
  220.     vorbis_comment_init(&s->vc);
  221.     if (!(avctx->flags & CODEC_FLAG_BITEXACT))
  222.         vorbis_comment_add_tag(&s->vc, "encoder", LIBAVCODEC_IDENT);
  223.  
  224.     if ((ret = vorbis_analysis_headerout(&s->vd, &s->vc, &header, &header_comm,
  225.                                          &header_code))) {
  226.         ret = vorbis_error_to_averror(ret);
  227.         goto error;
  228.     }
  229.  
  230.     avctx->extradata_size = 1 + xiph_len(header.bytes)      +
  231.                                 xiph_len(header_comm.bytes) +
  232.                                 header_code.bytes;
  233.     p = avctx->extradata = av_malloc(avctx->extradata_size +
  234.                                      FF_INPUT_BUFFER_PADDING_SIZE);
  235.     if (!p) {
  236.         ret = AVERROR(ENOMEM);
  237.         goto error;
  238.     }
  239.     p[0]    = 2;
  240.     offset  = 1;
  241.     offset += av_xiphlacing(&p[offset], header.bytes);
  242.     offset += av_xiphlacing(&p[offset], header_comm.bytes);
  243.     memcpy(&p[offset], header.packet, header.bytes);
  244.     offset += header.bytes;
  245.     memcpy(&p[offset], header_comm.packet, header_comm.bytes);
  246.     offset += header_comm.bytes;
  247.     memcpy(&p[offset], header_code.packet, header_code.bytes);
  248.     offset += header_code.bytes;
  249.     av_assert0(offset == avctx->extradata_size);
  250.  
  251.     if ((ret = avpriv_vorbis_parse_extradata(avctx, &s->vp)) < 0) {
  252.         av_log(avctx, AV_LOG_ERROR, "invalid extradata\n");
  253.         return ret;
  254.     }
  255.  
  256.     vorbis_comment_clear(&s->vc);
  257.  
  258.     avctx->frame_size = OGGVORBIS_FRAME_SIZE;
  259.     ff_af_queue_init(avctx, &s->afq);
  260.  
  261.     s->pkt_fifo = av_fifo_alloc(BUFFER_SIZE);
  262.     if (!s->pkt_fifo) {
  263.         ret = AVERROR(ENOMEM);
  264.         goto error;
  265.     }
  266.  
  267.     return 0;
  268. error:
  269.     oggvorbis_encode_close(avctx);
  270.     return ret;
  271. }
  272.  
  273. static int oggvorbis_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
  274.                                   const AVFrame *frame, int *got_packet_ptr)
  275. {
  276.     OggVorbisEncContext *s = avctx->priv_data;
  277.     ogg_packet op;
  278.     int ret, duration;
  279.  
  280.     /* send samples to libvorbis */
  281.     if (frame) {
  282.         const int samples = frame->nb_samples;
  283.         float **buffer;
  284.         int c, channels = s->vi.channels;
  285.  
  286.         buffer = vorbis_analysis_buffer(&s->vd, samples);
  287.         for (c = 0; c < channels; c++) {
  288.             int co = (channels > 8) ? c :
  289.                      ff_vorbis_encoding_channel_layout_offsets[channels - 1][c];
  290.             memcpy(buffer[c], frame->extended_data[co],
  291.                    samples * sizeof(*buffer[c]));
  292.         }
  293.         if ((ret = vorbis_analysis_wrote(&s->vd, samples)) < 0) {
  294.             av_log(avctx, AV_LOG_ERROR, "error in vorbis_analysis_wrote()\n");
  295.             return vorbis_error_to_averror(ret);
  296.         }
  297.         if ((ret = ff_af_queue_add(&s->afq, frame)) < 0)
  298.             return ret;
  299.     } else {
  300.         if (!s->eof)
  301.             if ((ret = vorbis_analysis_wrote(&s->vd, 0)) < 0) {
  302.                 av_log(avctx, AV_LOG_ERROR, "error in vorbis_analysis_wrote()\n");
  303.                 return vorbis_error_to_averror(ret);
  304.             }
  305.         s->eof = 1;
  306.     }
  307.  
  308.     /* retrieve available packets from libvorbis */
  309.     while ((ret = vorbis_analysis_blockout(&s->vd, &s->vb)) == 1) {
  310.         if ((ret = vorbis_analysis(&s->vb, NULL)) < 0)
  311.             break;
  312.         if ((ret = vorbis_bitrate_addblock(&s->vb)) < 0)
  313.             break;
  314.  
  315.         /* add any available packets to the output packet buffer */
  316.         while ((ret = vorbis_bitrate_flushpacket(&s->vd, &op)) == 1) {
  317.             if (av_fifo_space(s->pkt_fifo) < sizeof(ogg_packet) + op.bytes) {
  318.                 av_log(avctx, AV_LOG_ERROR, "packet buffer is too small\n");
  319.                 return AVERROR_BUG;
  320.             }
  321.             av_fifo_generic_write(s->pkt_fifo, &op, sizeof(ogg_packet), NULL);
  322.             av_fifo_generic_write(s->pkt_fifo, op.packet, op.bytes, NULL);
  323.         }
  324.         if (ret < 0) {
  325.             av_log(avctx, AV_LOG_ERROR, "error getting available packets\n");
  326.             break;
  327.         }
  328.     }
  329.     if (ret < 0) {
  330.         av_log(avctx, AV_LOG_ERROR, "error getting available packets\n");
  331.         return vorbis_error_to_averror(ret);
  332.     }
  333.  
  334.     /* check for available packets */
  335.     if (av_fifo_size(s->pkt_fifo) < sizeof(ogg_packet))
  336.         return 0;
  337.  
  338.     av_fifo_generic_read(s->pkt_fifo, &op, sizeof(ogg_packet), NULL);
  339.  
  340.     if ((ret = ff_alloc_packet2(avctx, avpkt, op.bytes)) < 0)
  341.         return ret;
  342.     av_fifo_generic_read(s->pkt_fifo, avpkt->data, op.bytes, NULL);
  343.  
  344.     avpkt->pts = ff_samples_to_time_base(avctx, op.granulepos);
  345.  
  346.     duration = avpriv_vorbis_parse_frame(&s->vp, avpkt->data, avpkt->size);
  347.     if (duration > 0) {
  348.         /* we do not know encoder delay until we get the first packet from
  349.          * libvorbis, so we have to update the AudioFrameQueue counts */
  350.         if (!avctx->delay && s->afq.frames) {
  351.             avctx->delay              = duration;
  352.             av_assert0(!s->afq.remaining_delay);
  353.             s->afq.frames->duration  += duration;
  354.             s->afq.frames->pts       -= duration;
  355.             s->afq.remaining_samples += duration;
  356.         }
  357.         ff_af_queue_remove(&s->afq, duration, &avpkt->pts, &avpkt->duration);
  358.     }
  359.  
  360.     *got_packet_ptr = 1;
  361.     return 0;
  362. }
  363.  
  364. AVCodec ff_libvorbis_encoder = {
  365.     .name           = "libvorbis",
  366.     .long_name      = NULL_IF_CONFIG_SMALL("libvorbis"),
  367.     .type           = AVMEDIA_TYPE_AUDIO,
  368.     .id             = AV_CODEC_ID_VORBIS,
  369.     .priv_data_size = sizeof(OggVorbisEncContext),
  370.     .init           = oggvorbis_encode_init,
  371.     .encode2        = oggvorbis_encode_frame,
  372.     .close          = oggvorbis_encode_close,
  373.     .capabilities   = CODEC_CAP_DELAY,
  374.     .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
  375.                                                       AV_SAMPLE_FMT_NONE },
  376.     .priv_class     = &vorbis_class,
  377.     .defaults       = defaults,
  378. };
  379.