X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=libavcodec%2Flibtheoraenc.c;h=9ed9a50493755b48f84122278e11be0835af4f82;hb=4628443ca3534060888dd0015b229337eac13fd2;hp=04b88128824fe1ddb9a7ca3da5801eed34acd973;hpb=870ee6f71579f2f3f20dee93d6246d12871c280d;p=ffmpeg diff --git a/libavcodec/libtheoraenc.c b/libavcodec/libtheoraenc.c index 04b88128824..9ed9a504937 100644 --- a/libavcodec/libtheoraenc.c +++ b/libavcodec/libtheoraenc.c @@ -1,27 +1,27 @@ /* * Copyright (c) 2006 Paul Richards * - * This file is part of FFmpeg. + * This file is part of Libav. * - * FFmpeg is free software; you can redistribute it and/or + * Libav is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * - * FFmpeg is distributed in the hope that it will be useful, + * Libav is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public - * License along with FFmpeg; if not, write to the Free Software + * License along with Libav; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ -/*! - * \file libtheoraenc.c - * \brief Theora encoder using libtheora. - * \author Paul Richards +/** + * @file + * @brief Theora encoder using libtheora. + * @author Paul Richards * * A lot of this is copy / paste from other output codecs in * libavcodec or pure guesswork (or both). @@ -30,26 +30,36 @@ * and o_ prefixes on variables which are libogg types. */ -/* FFmpeg includes */ +/* Libav includes */ +#include "libavutil/common.h" #include "libavutil/intreadwrite.h" +#include "libavutil/pixdesc.h" #include "libavutil/log.h" +#include "libavutil/base64.h" #include "avcodec.h" +#include "internal.h" /* libtheora includes */ -#include - -typedef struct TheoraContext{ - theora_state t_state; +#include + +typedef struct TheoraContext { + th_enc_ctx *t_state; + uint8_t *stats; + int stats_size; + int stats_offset; + int uv_hshift; + int uv_vshift; + int keyframe_mask; } TheoraContext; -/*! - Concatenates an ogg_packet into the extradata. -*/ -static int concatenate_packet(unsigned int* offset, AVCodecContext* avc_context, const ogg_packet* packet) +/** Concatenate an ogg_packet into the extradata. */ +static int concatenate_packet(unsigned int* offset, + AVCodecContext* avc_context, + const ogg_packet* packet) { - char* message = NULL; - uint8_t* newdata = NULL; + const char* message = NULL; int newsize = avc_context->extradata_size + 2 + packet->bytes; + int err = AVERROR_INVALIDDATA; if (packet->bytes < 0) { message = "ogg_packet has negative size"; @@ -58,231 +68,318 @@ static int concatenate_packet(unsigned int* offset, AVCodecContext* avc_context, } else if (newsize < avc_context->extradata_size) { message = "extradata_size would overflow"; } else { - newdata = av_realloc(avc_context->extradata, newsize); - if (newdata == NULL) { + if ((err = av_reallocp(&avc_context->extradata, newsize)) < 0) { + avc_context->extradata_size = 0; message = "av_realloc failed"; } } - if (message != NULL) { + if (message) { av_log(avc_context, AV_LOG_ERROR, "concatenate_packet failed: %s\n", message); - return -1; + return err; } - avc_context->extradata = newdata; avc_context->extradata_size = newsize; AV_WB16(avc_context->extradata + (*offset), packet->bytes); *offset += 2; - memcpy( avc_context->extradata + (*offset), packet->packet, packet->bytes ); + memcpy(avc_context->extradata + (*offset), packet->packet, packet->bytes); (*offset) += packet->bytes; return 0; } +static int get_stats(AVCodecContext *avctx, int eos) +{ +#ifdef TH_ENCCTL_2PASS_OUT + TheoraContext *h = avctx->priv_data; + uint8_t *buf; + int bytes; + + bytes = th_encode_ctl(h->t_state, TH_ENCCTL_2PASS_OUT, &buf, sizeof(buf)); + if (bytes < 0) { + av_log(avctx, AV_LOG_ERROR, "Error getting first pass stats\n"); + return -1; + } + if (!eos) { + h->stats = av_fast_realloc(h->stats, &h->stats_size, + h->stats_offset + bytes); + if (!h->stats) + return AVERROR(ENOMEM); + memcpy(h->stats + h->stats_offset, buf, bytes); + h->stats_offset += bytes; + } else { + int b64_size = AV_BASE64_SIZE(h->stats_offset); + // libtheora generates a summary header at the end + memcpy(h->stats, buf, bytes); + avctx->stats_out = av_malloc(b64_size); + if (!avctx->stats_out) + return AVERROR(ENOMEM); + av_base64_encode(avctx->stats_out, b64_size, h->stats, h->stats_offset); + } + return 0; +#else + av_log(avctx, AV_LOG_ERROR, "libtheora too old to support 2pass\n"); + return -1; +#endif +} + +// libtheora won't read the entire buffer we give it at once, so we have to +// repeatedly submit it... +static int submit_stats(AVCodecContext *avctx) +{ +#ifdef TH_ENCCTL_2PASS_IN + TheoraContext *h = avctx->priv_data; + int bytes; + if (!h->stats) { + if (!avctx->stats_in) { + av_log(avctx, AV_LOG_ERROR, "No statsfile for second pass\n"); + return -1; + } + h->stats_size = strlen(avctx->stats_in) * 3/4; + h->stats = av_malloc(h->stats_size); + if (!h->stats) + return AVERROR(ENOMEM); + h->stats_size = av_base64_decode(h->stats, avctx->stats_in, h->stats_size); + } + while (h->stats_size - h->stats_offset > 0) { + bytes = th_encode_ctl(h->t_state, TH_ENCCTL_2PASS_IN, + h->stats + h->stats_offset, + h->stats_size - h->stats_offset); + if (bytes < 0) { + av_log(avctx, AV_LOG_ERROR, "Error submitting stats\n"); + return -1; + } + if (!bytes) + return 0; + h->stats_offset += bytes; + } + return 0; +#else + av_log(avctx, AV_LOG_ERROR, "libtheora too old to support 2pass\n"); + return -1; +#endif +} + static av_cold int encode_init(AVCodecContext* avc_context) { - theora_info t_info; - theora_comment t_comment; + th_info t_info; + th_comment t_comment; ogg_packet o_packet; unsigned int offset; TheoraContext *h = avc_context->priv_data; + uint32_t gop_size = avc_context->gop_size; /* Set up the theora_info struct */ - theora_info_init( &t_info ); - t_info.width = FFALIGN(avc_context->width, 16); - t_info.height = FFALIGN(avc_context->height, 16); - t_info.frame_width = avc_context->width; - t_info.frame_height = avc_context->height; - t_info.offset_x = 0; - t_info.offset_y = avc_context->height & 0xf; + th_info_init(&t_info); + t_info.frame_width = FFALIGN(avc_context->width, 16); + t_info.frame_height = FFALIGN(avc_context->height, 16); + t_info.pic_width = avc_context->width; + t_info.pic_height = avc_context->height; + t_info.pic_x = 0; + t_info.pic_y = 0; /* Swap numerator and denominator as time_base in AVCodecContext gives the * time period between frames, but theora_info needs the framerate. */ - t_info.fps_numerator = avc_context->time_base.den; + t_info.fps_numerator = avc_context->time_base.den; t_info.fps_denominator = avc_context->time_base.num; - if (avc_context->sample_aspect_ratio.num != 0) { - t_info.aspect_numerator = avc_context->sample_aspect_ratio.num; + if (avc_context->sample_aspect_ratio.num) { + t_info.aspect_numerator = avc_context->sample_aspect_ratio.num; t_info.aspect_denominator = avc_context->sample_aspect_ratio.den; } else { - t_info.aspect_numerator = 1; + t_info.aspect_numerator = 1; t_info.aspect_denominator = 1; } - t_info.colorspace = OC_CS_UNSPECIFIED; - t_info.pixelformat = OC_PF_420; - t_info.target_bitrate = avc_context->bit_rate; - t_info.keyframe_frequency = avc_context->gop_size; - t_info.keyframe_frequency_force = avc_context->gop_size; - t_info.keyframe_mindistance = avc_context->keyint_min; - t_info.quality = 0; - - t_info.quick_p = 1; - t_info.dropframes_p = 0; - t_info.keyframe_auto_p = 1; - t_info.keyframe_data_target_bitrate = t_info.target_bitrate * 1.5; - t_info.keyframe_auto_threshold = 80; - t_info.noise_sensitivity = 1; - t_info.sharpness = 0; + + if (avc_context->color_primaries == AVCOL_PRI_BT470M) + t_info.colorspace = TH_CS_ITU_REC_470M; + else if (avc_context->color_primaries == AVCOL_PRI_BT470BG) + t_info.colorspace = TH_CS_ITU_REC_470BG; + else + t_info.colorspace = TH_CS_UNSPECIFIED; + + if (avc_context->pix_fmt == AV_PIX_FMT_YUV420P) + t_info.pixel_fmt = TH_PF_420; + else if (avc_context->pix_fmt == AV_PIX_FMT_YUV422P) + t_info.pixel_fmt = TH_PF_422; + else if (avc_context->pix_fmt == AV_PIX_FMT_YUV444P) + t_info.pixel_fmt = TH_PF_444; + else { + av_log(avc_context, AV_LOG_ERROR, "Unsupported pix_fmt\n"); + return -1; + } + av_pix_fmt_get_chroma_sub_sample(avc_context->pix_fmt, + &h->uv_hshift, &h->uv_vshift); + + if (avc_context->flags & AV_CODEC_FLAG_QSCALE) { + /* to be constant with the libvorbis implementation, clip global_quality to 0 - 10 + Theora accepts a quality parameter p, which is: + * 0 <= p <=63 + * an int value + */ + t_info.quality = av_clipf(avc_context->global_quality / (float)FF_QP2LAMBDA, 0, 10) * 6.3; + t_info.target_bitrate = 0; + } else { + t_info.target_bitrate = avc_context->bit_rate; + t_info.quality = 0; + } /* Now initialise libtheora */ - if (theora_encode_init( &(h->t_state), &t_info ) != 0) { + h->t_state = th_encode_alloc(&t_info); + if (!h->t_state) { av_log(avc_context, AV_LOG_ERROR, "theora_encode_init failed\n"); return -1; } + h->keyframe_mask = (1 << t_info.keyframe_granule_shift) - 1; /* Clear up theora_info struct */ - theora_info_clear( &t_info ); + th_info_clear(&t_info); + + if (th_encode_ctl(h->t_state, TH_ENCCTL_SET_KEYFRAME_FREQUENCY_FORCE, + &gop_size, sizeof(gop_size))) { + av_log(avc_context, AV_LOG_ERROR, "Error setting GOP size\n"); + return -1; + } + + // need to enable 2 pass (via TH_ENCCTL_2PASS_) before encoding headers + if (avc_context->flags & AV_CODEC_FLAG_PASS1) { + if (get_stats(avc_context, 0)) + return -1; + } else if (avc_context->flags & AV_CODEC_FLAG_PASS2) { + if (submit_stats(avc_context)) + return -1; + } /* Output first header packet consisting of theora header, comment, and tables. Each one is prefixed with a 16bit size, then they - are concatenated together into ffmpeg's extradata. + are concatenated together into libavcodec's extradata. */ offset = 0; - /* Header */ - theora_encode_header( &(h->t_state), &o_packet ); - if (concatenate_packet( &offset, avc_context, &o_packet ) != 0) { - return -1; - } + /* Headers */ + th_comment_init(&t_comment); - /* Comment */ - theora_comment_init( &t_comment ); - theora_encode_comment( &t_comment, &o_packet ); - if (concatenate_packet( &offset, avc_context, &o_packet ) != 0) { - return -1; - } - /* Clear up theora_comment struct before we reset the packet */ - theora_comment_clear( &t_comment ); - /* And despite documentation to the contrary, theora_comment_clear - * does not release the packet */ - ogg_packet_clear(&o_packet); - - /* Tables */ - theora_encode_tables( &(h->t_state), &o_packet ); - if (concatenate_packet( &offset, avc_context, &o_packet ) != 0) { - return -1; - } + while (th_encode_flushheader(h->t_state, &t_comment, &o_packet)) + if (concatenate_packet(&offset, avc_context, &o_packet)) + return -1; - /* Set up the output AVFrame */ - avc_context->coded_frame= avcodec_alloc_frame(); + th_comment_clear(&t_comment); return 0; } -static int encode_frame( - AVCodecContext* avc_context, - uint8_t *outbuf, - int buf_size, - void *data) +static int encode_frame(AVCodecContext* avc_context, AVPacket *pkt, + const AVFrame *frame, int *got_packet) { - yuv_buffer t_yuv_buffer; + th_ycbcr_buffer t_yuv_buffer; TheoraContext *h = avc_context->priv_data; - AVFrame *frame = data; ogg_packet o_packet; - int result; - - assert(avc_context->pix_fmt == PIX_FMT_YUV420P); + int result, i, ret; + + // EOS, finish and get 1st pass stats if applicable + if (!frame) { + th_encode_packetout(h->t_state, 1, &o_packet); + if (avc_context->flags & AV_CODEC_FLAG_PASS1) + if (get_stats(avc_context, 1)) + return -1; + return 0; + } /* Copy planes to the theora yuv_buffer */ - if (frame->linesize[1] != frame->linesize[2]) { - av_log(avc_context, AV_LOG_ERROR, "U and V stride differ\n"); - return -1; + for (i = 0; i < 3; i++) { + t_yuv_buffer[i].width = FFALIGN(avc_context->width, 16) >> (i && h->uv_hshift); + t_yuv_buffer[i].height = FFALIGN(avc_context->height, 16) >> (i && h->uv_vshift); + t_yuv_buffer[i].stride = frame->linesize[i]; + t_yuv_buffer[i].data = frame->data[i]; } - t_yuv_buffer.y_width = FFALIGN(avc_context->width, 16); - t_yuv_buffer.y_height = FFALIGN(avc_context->height, 16); - t_yuv_buffer.y_stride = frame->linesize[0]; - t_yuv_buffer.uv_width = t_yuv_buffer.y_width / 2; - t_yuv_buffer.uv_height = t_yuv_buffer.y_height / 2; - t_yuv_buffer.uv_stride = frame->linesize[1]; - - t_yuv_buffer.y = frame->data[0]; - t_yuv_buffer.u = frame->data[1]; - t_yuv_buffer.v = frame->data[2]; + if (avc_context->flags & AV_CODEC_FLAG_PASS2) + if (submit_stats(avc_context)) + return -1; /* Now call into theora_encode_YUVin */ - result = theora_encode_YUVin( &(h->t_state), &t_yuv_buffer ); - if (result != 0) { + result = th_encode_ycbcr_in(h->t_state, t_yuv_buffer); + if (result) { const char* message; switch (result) { - case -1: - message = "differing frame sizes"; - break; - case OC_EINVAL: - message = "encoder is not ready or is finished"; - break; - default: - message = "unknown reason"; - break; + case -1: + message = "differing frame sizes"; + break; + case TH_EINVAL: + message = "encoder is not ready or is finished"; + break; + default: + message = "unknown reason"; + break; } av_log(avc_context, AV_LOG_ERROR, "theora_encode_YUVin failed (%s) [%d]\n", message, result); return -1; } + if (avc_context->flags & AV_CODEC_FLAG_PASS1) + if (get_stats(avc_context, 0)) + return -1; + /* Pick up returned ogg_packet */ - result = theora_encode_packetout( &(h->t_state), 0, &o_packet ); + result = th_encode_packetout(h->t_state, 0, &o_packet); switch (result) { - case 0: - /* No packet is ready */ - return 0; - case 1: - /* Success, we have a packet */ - break; - default: - av_log(avc_context, AV_LOG_ERROR, "theora_encode_packetout failed [%d]\n", result); - return -1; + case 0: + /* No packet is ready */ + return 0; + case 1: + /* Success, we have a packet */ + break; + default: + av_log(avc_context, AV_LOG_ERROR, "theora_encode_packetout failed [%d]\n", result); + return -1; } /* Copy ogg_packet content out to buffer */ - if (buf_size < o_packet.bytes) { - av_log(avc_context, AV_LOG_ERROR, "encoded frame too large\n"); - return -1; + if ((ret = ff_alloc_packet(pkt, o_packet.bytes)) < 0) { + av_log(avc_context, AV_LOG_ERROR, "Error getting output packet of size %ld.\n", o_packet.bytes); + return ret; } - memcpy(outbuf, o_packet.packet, o_packet.bytes); + memcpy(pkt->data, o_packet.packet, o_packet.bytes); + + // HACK: assumes no encoder delay, this is true until libtheora becomes + // multithreaded (which will be disabled unless explicitly requested) + pkt->pts = pkt->dts = frame->pts; +#if FF_API_CODED_FRAME +FF_DISABLE_DEPRECATION_WARNINGS + avc_context->coded_frame->key_frame = !(o_packet.granulepos & h->keyframe_mask); +FF_ENABLE_DEPRECATION_WARNINGS +#endif + if (!(o_packet.granulepos & h->keyframe_mask)) + pkt->flags |= AV_PKT_FLAG_KEY; + *got_packet = 1; - return o_packet.bytes; + return 0; } static av_cold int encode_close(AVCodecContext* avc_context) { - ogg_packet o_packet; TheoraContext *h = avc_context->priv_data; - int result; - const char* message; - result = theora_encode_packetout( &(h->t_state), 1, &o_packet ); - theora_clear( &(h->t_state) ); - av_freep(&avc_context->coded_frame); + th_encode_free(h->t_state); + av_freep(&h->stats); + av_freep(&avc_context->stats_out); av_freep(&avc_context->extradata); avc_context->extradata_size = 0; - switch (result) { - case 0:/* No packet is ready */ - case -1:/* Encoding finished */ - return 0; - case 1: - /* We have a packet */ - message = "gave us a packet"; - break; - default: - message = "unknown reason"; - break; - } - av_log(avc_context, AV_LOG_ERROR, "theora_encode_packetout failed (%s) [%d]\n", message, result); - return -1; + return 0; } -static const enum PixelFormat supported_pixel_formats[] = { PIX_FMT_YUV420P, PIX_FMT_NONE }; - -/*! AVCodec struct exposed to libavcodec */ -AVCodec libtheora_encoder = -{ - .name = "libtheora", - .type = CODEC_TYPE_VIDEO, - .id = CODEC_ID_THEORA, +/** AVCodec struct exposed to libavcodec */ +AVCodec ff_libtheora_encoder = { + .name = "libtheora", + .long_name = NULL_IF_CONFIG_SMALL("libtheora Theora"), + .type = AVMEDIA_TYPE_VIDEO, + .id = AV_CODEC_ID_THEORA, .priv_data_size = sizeof(TheoraContext), - .init = encode_init, - .close = encode_close, - .encode = encode_frame, - .pix_fmts = supported_pixel_formats, - .long_name = NULL_IF_CONFIG_SMALL("libtheora Theora"), + .init = encode_init, + .close = encode_close, + .encode2 = encode_frame, + .capabilities = AV_CODEC_CAP_DELAY, // needed to get the statsfile summary + .pix_fmts = (const enum AVPixelFormat[]){ + AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_NONE + }, };