git.sesse.net Git - ffmpeg/blob - libavcodec/libtheoraenc.c

   1 /*
   2  * Copyright (c) 2006 Paul Richards <paul.richards@gmail.com>
   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 /*!
  22  * \file libtheoraenc.c
  23  * \brief Theora encoder using libtheora.
  24  * \author Paul Richards <paul.richards@gmail.com>
  25  *
  26  * A lot of this is copy / paste from other output codecs in
  27  * libavcodec or pure guesswork (or both).
  28  *
  29  * I have used t_ prefixes on variables which are libtheora types
  30  * and o_ prefixes on variables which are libogg types.
  31  */
  32
  33 /* FFmpeg includes */
  34 #include "libavutil/intreadwrite.h"
  35 #include "libavutil/log.h"
  36 #include "avcodec.h"
  37
  38 /* libtheora includes */
  39 #include <theora/theoraenc.h>
  40
  41 typedef struct TheoraContext {
  42     th_enc_ctx *t_state;
  43 } TheoraContext;
  44
  45 /*!
  46     Concatenates an ogg_packet into the extradata.
  47 */
  48 static int concatenate_packet(unsigned int* offset,
  49                               AVCodecContext* avc_context,
  50                               const ogg_packet* packet)
  51 {
  52     const char* message = NULL;
  53     uint8_t* newdata    = NULL;
  54     int newsize = avc_context->extradata_size + 2 + packet->bytes;
  55
  56     if (packet->bytes < 0) {
  57         message = "ogg_packet has negative size";
  58     } else if (packet->bytes > 0xffff) {
  59         message = "ogg_packet is larger than 65535 bytes";
  60     } else if (newsize < avc_context->extradata_size) {
  61         message = "extradata_size would overflow";
  62     } else {
  63         newdata = av_realloc(avc_context->extradata, newsize);
  64         if (!newdata)
  65             message = "av_realloc failed";
  66     }
  67     if (message) {
  68         av_log(avc_context, AV_LOG_ERROR, "concatenate_packet failed: %s\n", message);
  69         return -1;
  70     }
  71
  72     avc_context->extradata      = newdata;
  73     avc_context->extradata_size = newsize;
  74     AV_WB16(avc_context->extradata + (*offset), packet->bytes);
  75     *offset += 2;
  76     memcpy(avc_context->extradata + (*offset), packet->packet, packet->bytes);
  77     (*offset) += packet->bytes;
  78     return 0;
  79 }
  80
  81 static av_cold int encode_init(AVCodecContext* avc_context)
  82 {
  83     th_info t_info;
  84     th_comment t_comment;
  85     ogg_packet o_packet;
  86     unsigned int offset;
  87     TheoraContext *h = avc_context->priv_data;
  88     uint32_t gop_size = avc_context->gop_size;
  89
  90     /* Set up the theora_info struct */
  91     th_info_init(&t_info);
  92     t_info.frame_width  = FFALIGN(avc_context->width,  16);
  93     t_info.frame_height = FFALIGN(avc_context->height, 16);
  94     t_info.pic_width    = avc_context->width;
  95     t_info.pic_height   = avc_context->height;
  96     t_info.pic_x        = 0;
  97     t_info.pic_y        = 0;
  98     /* Swap numerator and denominator as time_base in AVCodecContext gives the
  99      * time period between frames, but theora_info needs the framerate.  */
 100     t_info.fps_numerator   = avc_context->time_base.den;
 101     t_info.fps_denominator = avc_context->time_base.num;
 102     if (avc_context->sample_aspect_ratio.num) {
 103         t_info.aspect_numerator   = avc_context->sample_aspect_ratio.num;
 104         t_info.aspect_denominator = avc_context->sample_aspect_ratio.den;
 105     } else {
 106         t_info.aspect_numerator   = 1;
 107         t_info.aspect_denominator = 1;
 108     }
 109     t_info.colorspace = TH_CS_UNSPECIFIED;
 110     t_info.pixel_fmt  = TH_PF_420;
 111
 112     if (avc_context->flags & CODEC_FLAG_QSCALE) {
 113         /* to be constant with the libvorbis implementation, clip global_quality to 0 - 10
 114            Theora accepts a quality parameter p, which is:
 115                 * 0 <= p <=63
 116                 * an int value
 117          */
 118         t_info.quality        = av_clip(avc_context->global_quality / (float)FF_QP2LAMBDA, 0, 10) * 6.3;
 119         t_info.target_bitrate = 0;
 120     } else {
 121         t_info.target_bitrate = avc_context->bit_rate;
 122         t_info.quality        = 0;
 123     }
 124
 125     /* Now initialise libtheora */
 126     h->t_state = th_encode_alloc(&t_info);
 127     if (!h->t_state) {
 128         av_log(avc_context, AV_LOG_ERROR, "theora_encode_init failed\n");
 129         return -1;
 130     }
 131
 132     /* Clear up theora_info struct */
 133     th_info_clear(&t_info);
 134
 135     if (th_encode_ctl(h->t_state, TH_ENCCTL_SET_KEYFRAME_FREQUENCY_FORCE,
 136                       &gop_size, sizeof(gop_size))) {
 137         av_log(avc_context, AV_LOG_ERROR, "Error setting GOP size\n");
 138         return -1;
 139     }
 140
 141     /*
 142         Output first header packet consisting of theora
 143         header, comment, and tables.
 144
 145         Each one is prefixed with a 16bit size, then they
 146         are concatenated together into ffmpeg's extradata.
 147     */
 148     offset = 0;
 149
 150     /* Headers */
 151     th_comment_init(&t_comment);
 152
 153     while (th_encode_flushheader(h->t_state, &t_comment, &o_packet))
 154         if (concatenate_packet(&offset, avc_context, &o_packet))
 155             return -1;
 156
 157     th_comment_clear(&t_comment);
 158
 159     /* Set up the output AVFrame */
 160     avc_context->coded_frame= avcodec_alloc_frame();
 161
 162     return 0;
 163 }
 164
 165 static int encode_frame(AVCodecContext* avc_context, uint8_t *outbuf,
 166                         int buf_size, void *data)
 167 {
 168     th_ycbcr_buffer t_yuv_buffer;
 169     TheoraContext *h = avc_context->priv_data;
 170     AVFrame *frame = data;
 171     ogg_packet o_packet;
 172     int result, i;
 173
 174     assert(avc_context->pix_fmt == PIX_FMT_YUV420P);
 175
 176     /* Copy planes to the theora yuv_buffer */
 177     for (i = 0; i < 3; i++) {
 178         t_yuv_buffer[i].width  = FFALIGN(avc_context->width,  16) >> !!i;
 179         t_yuv_buffer[i].height = FFALIGN(avc_context->height, 16) >> !!i;
 180         t_yuv_buffer[i].stride = frame->linesize[i];
 181         t_yuv_buffer[i].data   = frame->data[i];
 182     }
 183
 184     /* Now call into theora_encode_YUVin */
 185     result = th_encode_ycbcr_in(h->t_state, t_yuv_buffer);
 186     if (result) {
 187         const char* message;
 188         switch (result) {
 189         case -1:
 190             message = "differing frame sizes";
 191             break;
 192         case TH_EINVAL:
 193             message = "encoder is not ready or is finished";
 194             break;
 195         default:
 196             message = "unknown reason";
 197             break;
 198         }
 199         av_log(avc_context, AV_LOG_ERROR, "theora_encode_YUVin failed (%s) [%d]\n", message, result);
 200         return -1;
 201     }
 202
 203     /* Pick up returned ogg_packet */
 204     result = th_encode_packetout(h->t_state, 0, &o_packet);
 205     switch (result) {
 206     case 0:
 207         /* No packet is ready */
 208         return 0;
 209     case 1:
 210         /* Success, we have a packet */
 211         break;
 212     default:
 213         av_log(avc_context, AV_LOG_ERROR, "theora_encode_packetout failed [%d]\n", result);
 214         return -1;
 215     }
 216
 217     /* Copy ogg_packet content out to buffer */
 218     if (buf_size < o_packet.bytes) {
 219         av_log(avc_context, AV_LOG_ERROR, "encoded frame too large\n");
 220         return -1;
 221     }
 222     memcpy(outbuf, o_packet.packet, o_packet.bytes);
 223
 224     // HACK: does not take codec delay into account (neither does the decoder though)
 225     avc_context->coded_frame->pts = frame->pts;
 226
 227     return o_packet.bytes;
 228 }
 229
 230 static av_cold int encode_close(AVCodecContext* avc_context)
 231 {
 232     ogg_packet o_packet;
 233     TheoraContext *h = avc_context->priv_data;
 234     int result;
 235     const char* message;
 236
 237     result = th_encode_packetout(h->t_state, 1, &o_packet);
 238     th_encode_free(h->t_state);
 239     av_freep(&avc_context->coded_frame);
 240     av_freep(&avc_context->extradata);
 241     avc_context->extradata_size = 0;
 242
 243     switch (result) {
 244     case 0:  /* No packet is ready */
 245     case -1: /* Encoding finished */
 246         return 0;
 247     case 1:
 248         /* We have a packet */
 249         message = "gave us a packet";
 250         break;
 251     default:
 252         message = "unknown reason";
 253         break;
 254     }
 255     av_log(avc_context, AV_LOG_ERROR, "theora_encode_packetout failed (%s) [%d]\n", message, result);
 256     return -1;
 257 }
 258
 259 static const enum PixelFormat supported_pixel_formats[] = { PIX_FMT_YUV420P, PIX_FMT_NONE };
 260
 261 /*! AVCodec struct exposed to libavcodec */
 262 AVCodec libtheora_encoder = {
 263     .name = "libtheora",
 264     .type = CODEC_TYPE_VIDEO,
 265     .id = CODEC_ID_THEORA,
 266     .priv_data_size = sizeof(TheoraContext),
 267     .init = encode_init,
 268     .close = encode_close,
 269     .encode = encode_frame,
 270     .pix_fmts = supported_pixel_formats,
 271     .long_name = NULL_IF_CONFIG_SMALL("libtheora Theora"),
 272 };