FFmpeg
libtheoraenc.c
Go to the documentation of this file.
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
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/common.h"
35 #include "libavutil/intreadwrite.h"
36 #include "libavutil/pixdesc.h"
37 #include "libavutil/log.h"
38 #include "libavutil/base64.h"
39 #include "avcodec.h"
40 #include "encode.h"
41 #include "internal.h"
42 
43 /* libtheora includes */
44 #include <theora/theoraenc.h>
45 
46 typedef struct TheoraContext {
47  th_enc_ctx *t_state;
48  uint8_t *stats;
51  int uv_hshift;
52  int uv_vshift;
55 
56 /** Concatenate an ogg_packet into the extradata. */
57 static int concatenate_packet(unsigned int* offset,
58  AVCodecContext* avc_context,
59  const ogg_packet* packet)
60 {
61  const char* message = NULL;
62  int newsize = avc_context->extradata_size + 2 + packet->bytes;
63  int err = AVERROR_INVALIDDATA;
64 
65  if (packet->bytes < 0) {
66  message = "ogg_packet has negative size";
67  } else if (packet->bytes > 0xffff) {
68  message = "ogg_packet is larger than 65535 bytes";
69  } else if (newsize < avc_context->extradata_size) {
70  message = "extradata_size would overflow";
71  } else {
72  if ((err = av_reallocp(&avc_context->extradata, newsize)) < 0) {
73  avc_context->extradata_size = 0;
74  message = "av_realloc failed";
75  }
76  }
77  if (message) {
78  av_log(avc_context, AV_LOG_ERROR, "concatenate_packet failed: %s\n", message);
79  return err;
80  }
81 
82  avc_context->extradata_size = newsize;
83  AV_WB16(avc_context->extradata + (*offset), packet->bytes);
84  *offset += 2;
85  memcpy(avc_context->extradata + (*offset), packet->packet, packet->bytes);
86  (*offset) += packet->bytes;
87  return 0;
88 }
89 
90 static int get_stats(AVCodecContext *avctx, int eos)
91 {
92 #ifdef TH_ENCCTL_2PASS_OUT
93  TheoraContext *h = avctx->priv_data;
94  uint8_t *buf;
95  int bytes;
96 
97  bytes = th_encode_ctl(h->t_state, TH_ENCCTL_2PASS_OUT, &buf, sizeof(buf));
98  if (bytes < 0) {
99  av_log(avctx, AV_LOG_ERROR, "Error getting first pass stats\n");
100  return AVERROR_EXTERNAL;
101  }
102  if (!eos) {
103  void *tmp = av_fast_realloc(h->stats, &h->stats_size,
104  h->stats_offset + bytes);
105  if (!tmp)
106  return AVERROR(ENOMEM);
107  h->stats = tmp;
108  memcpy(h->stats + h->stats_offset, buf, bytes);
109  h->stats_offset += bytes;
110  } else {
111  int b64_size = AV_BASE64_SIZE(h->stats_offset);
112  // libtheora generates a summary header at the end
113  memcpy(h->stats, buf, bytes);
114  avctx->stats_out = av_malloc(b64_size);
115  if (!avctx->stats_out)
116  return AVERROR(ENOMEM);
117  av_base64_encode(avctx->stats_out, b64_size, h->stats, h->stats_offset);
118  }
119  return 0;
120 #else
121  av_log(avctx, AV_LOG_ERROR, "libtheora too old to support 2pass\n");
122  return AVERROR(ENOSUP);
123 #endif
124 }
125 
126 // libtheora won't read the entire buffer we give it at once, so we have to
127 // repeatedly submit it...
128 static int submit_stats(AVCodecContext *avctx)
129 {
130 #ifdef TH_ENCCTL_2PASS_IN
131  TheoraContext *h = avctx->priv_data;
132  int bytes;
133  if (!h->stats) {
134  if (!avctx->stats_in) {
135  av_log(avctx, AV_LOG_ERROR, "No statsfile for second pass\n");
136  return AVERROR(EINVAL);
137  }
138  h->stats_size = strlen(avctx->stats_in) * 3/4;
139  h->stats = av_malloc(h->stats_size);
140  if (!h->stats) {
141  h->stats_size = 0;
142  return AVERROR(ENOMEM);
143  }
144  h->stats_size = av_base64_decode(h->stats, avctx->stats_in, h->stats_size);
145  }
146  while (h->stats_size - h->stats_offset > 0) {
147  bytes = th_encode_ctl(h->t_state, TH_ENCCTL_2PASS_IN,
148  h->stats + h->stats_offset,
149  h->stats_size - h->stats_offset);
150  if (bytes < 0) {
151  av_log(avctx, AV_LOG_ERROR, "Error submitting stats\n");
152  return AVERROR_EXTERNAL;
153  }
154  if (!bytes)
155  return 0;
156  h->stats_offset += bytes;
157  }
158  return 0;
159 #else
160  av_log(avctx, AV_LOG_ERROR, "libtheora too old to support 2pass\n");
161  return AVERROR(ENOSUP);
162 #endif
163 }
164 
165 static av_cold int encode_init(AVCodecContext* avc_context)
166 {
167  th_info t_info;
168  th_comment t_comment;
169  ogg_packet o_packet;
170  unsigned int offset;
171  TheoraContext *h = avc_context->priv_data;
172  uint32_t gop_size = avc_context->gop_size;
173  int ret;
174 
175  /* Set up the theora_info struct */
176  th_info_init(&t_info);
177  t_info.frame_width = FFALIGN(avc_context->width, 16);
178  t_info.frame_height = FFALIGN(avc_context->height, 16);
179  t_info.pic_width = avc_context->width;
180  t_info.pic_height = avc_context->height;
181  t_info.pic_x = 0;
182  t_info.pic_y = 0;
183  /* Swap numerator and denominator as time_base in AVCodecContext gives the
184  * time period between frames, but theora_info needs the framerate. */
185  t_info.fps_numerator = avc_context->time_base.den;
186  t_info.fps_denominator = avc_context->time_base.num;
187  if (avc_context->sample_aspect_ratio.num) {
188  t_info.aspect_numerator = avc_context->sample_aspect_ratio.num;
189  t_info.aspect_denominator = avc_context->sample_aspect_ratio.den;
190  } else {
191  t_info.aspect_numerator = 1;
192  t_info.aspect_denominator = 1;
193  }
194 
195  if (avc_context->color_primaries == AVCOL_PRI_BT470M)
196  t_info.colorspace = TH_CS_ITU_REC_470M;
197  else if (avc_context->color_primaries == AVCOL_PRI_BT470BG)
198  t_info.colorspace = TH_CS_ITU_REC_470BG;
199  else
200  t_info.colorspace = TH_CS_UNSPECIFIED;
201 
202  if (avc_context->pix_fmt == AV_PIX_FMT_YUV420P)
203  t_info.pixel_fmt = TH_PF_420;
204  else if (avc_context->pix_fmt == AV_PIX_FMT_YUV422P)
205  t_info.pixel_fmt = TH_PF_422;
206  else if (avc_context->pix_fmt == AV_PIX_FMT_YUV444P)
207  t_info.pixel_fmt = TH_PF_444;
208  else {
209  av_log(avc_context, AV_LOG_ERROR, "Unsupported pix_fmt\n");
210  return AVERROR(EINVAL);
211  }
212  ret = av_pix_fmt_get_chroma_sub_sample(avc_context->pix_fmt, &h->uv_hshift, &h->uv_vshift);
213  if (ret)
214  return ret;
215 
216  if (avc_context->flags & AV_CODEC_FLAG_QSCALE) {
217  /* Clip global_quality in QP units to the [0 - 10] range
218  to be consistent with the libvorbis implementation.
219  Theora accepts a quality parameter which is an int value in
220  the [0 - 63] range.
221  */
222  t_info.quality = av_clipf(avc_context->global_quality / (float)FF_QP2LAMBDA, 0, 10) * 6.3;
223  t_info.target_bitrate = 0;
224  } else {
225  t_info.target_bitrate = avc_context->bit_rate;
226  t_info.quality = 0;
227  }
228 
229  /* Now initialise libtheora */
230  h->t_state = th_encode_alloc(&t_info);
231  if (!h->t_state) {
232  av_log(avc_context, AV_LOG_ERROR, "theora_encode_init failed\n");
233  return AVERROR_EXTERNAL;
234  }
235 
236  h->keyframe_mask = (1 << t_info.keyframe_granule_shift) - 1;
237  /* Clear up theora_info struct */
238  th_info_clear(&t_info);
239 
240  if (th_encode_ctl(h->t_state, TH_ENCCTL_SET_KEYFRAME_FREQUENCY_FORCE,
241  &gop_size, sizeof(gop_size))) {
242  av_log(avc_context, AV_LOG_ERROR, "Error setting GOP size\n");
243  return AVERROR_EXTERNAL;
244  }
245 
246  // need to enable 2 pass (via TH_ENCCTL_2PASS_) before encoding headers
247  if (avc_context->flags & AV_CODEC_FLAG_PASS1) {
248  if ((ret = get_stats(avc_context, 0)) < 0)
249  return ret;
250  } else if (avc_context->flags & AV_CODEC_FLAG_PASS2) {
251  if ((ret = submit_stats(avc_context)) < 0)
252  return ret;
253  }
254 
255  /*
256  Output first header packet consisting of theora
257  header, comment, and tables.
258 
259  Each one is prefixed with a 16-bit size, then they
260  are concatenated together into libavcodec's extradata.
261  */
262  offset = 0;
263 
264  /* Headers */
265  th_comment_init(&t_comment);
266 
267  while (th_encode_flushheader(h->t_state, &t_comment, &o_packet))
268  if ((ret = concatenate_packet(&offset, avc_context, &o_packet)) < 0)
269  return ret;
270 
271  th_comment_clear(&t_comment);
272 
273  return 0;
274 }
275 
276 static int encode_frame(AVCodecContext* avc_context, AVPacket *pkt,
277  const AVFrame *frame, int *got_packet)
278 {
279  th_ycbcr_buffer t_yuv_buffer;
280  TheoraContext *h = avc_context->priv_data;
281  ogg_packet o_packet;
282  int result, i, ret;
283 
284  // EOS, finish and get 1st pass stats if applicable
285  if (!frame) {
286  th_encode_packetout(h->t_state, 1, &o_packet);
287  if (avc_context->flags & AV_CODEC_FLAG_PASS1)
288  if ((ret = get_stats(avc_context, 1)) < 0)
289  return ret;
290  return 0;
291  }
292 
293  /* Copy planes to the theora yuv_buffer */
294  for (i = 0; i < 3; i++) {
295  t_yuv_buffer[i].width = FFALIGN(avc_context->width, 16) >> (i && h->uv_hshift);
296  t_yuv_buffer[i].height = FFALIGN(avc_context->height, 16) >> (i && h->uv_vshift);
297  t_yuv_buffer[i].stride = frame->linesize[i];
298  t_yuv_buffer[i].data = frame->data[i];
299  }
300 
301  if (avc_context->flags & AV_CODEC_FLAG_PASS2)
302  if ((ret = submit_stats(avc_context)) < 0)
303  return ret;
304 
305  /* Now call into theora_encode_YUVin */
306  result = th_encode_ycbcr_in(h->t_state, t_yuv_buffer);
307  if (result) {
308  const char* message;
309  switch (result) {
310  case -1:
311  message = "differing frame sizes";
312  break;
313  case TH_EINVAL:
314  message = "encoder is not ready or is finished";
315  break;
316  default:
317  message = "unknown reason";
318  break;
319  }
320  av_log(avc_context, AV_LOG_ERROR, "theora_encode_YUVin failed (%s) [%d]\n", message, result);
321  return AVERROR_EXTERNAL;
322  }
323 
324  if (avc_context->flags & AV_CODEC_FLAG_PASS1)
325  if ((ret = get_stats(avc_context, 0)) < 0)
326  return ret;
327 
328  /* Pick up returned ogg_packet */
329  result = th_encode_packetout(h->t_state, 0, &o_packet);
330  switch (result) {
331  case 0:
332  /* No packet is ready */
333  return 0;
334  case 1:
335  /* Success, we have a packet */
336  break;
337  default:
338  av_log(avc_context, AV_LOG_ERROR, "theora_encode_packetout failed [%d]\n", result);
339  return AVERROR_EXTERNAL;
340  }
341 
342  /* Copy ogg_packet content out to buffer */
343  if ((ret = ff_get_encode_buffer(avc_context, pkt, o_packet.bytes, 0)) < 0)
344  return ret;
345  memcpy(pkt->data, o_packet.packet, o_packet.bytes);
346 
347  // HACK: assumes no encoder delay, this is true until libtheora becomes
348  // multithreaded (which will be disabled unless explicitly requested)
349  pkt->pts = pkt->dts = frame->pts;
350  if (!(o_packet.granulepos & h->keyframe_mask))
352  *got_packet = 1;
353 
354  return 0;
355 }
356 
357 static av_cold int encode_close(AVCodecContext* avc_context)
358 {
359  TheoraContext *h = avc_context->priv_data;
360 
361  th_encode_free(h->t_state);
362  av_freep(&h->stats);
363  av_freep(&avc_context->stats_out);
364  avc_context->extradata_size = 0;
365 
366  return 0;
367 }
368 
369 /** AVCodec struct exposed to libavcodec */
371  .name = "libtheora",
372  .long_name = NULL_IF_CONFIG_SMALL("libtheora Theora"),
373  .type = AVMEDIA_TYPE_VIDEO,
374  .id = AV_CODEC_ID_THEORA,
375  .capabilities = AV_CODEC_CAP_DR1 |
376  AV_CODEC_CAP_DELAY /* for statsfile summary */,
377  .priv_data_size = sizeof(TheoraContext),
378  .init = encode_init,
379  .close = encode_close,
380  .encode2 = encode_frame,
381  .pix_fmts = (const enum AVPixelFormat[]){
383  },
384  .wrapper_name = "libtheora",
385 };
AVCodec
AVCodec.
Definition: codec.h:197
TheoraContext::uv_vshift
int uv_vshift
Definition: libtheoraenc.c:52
encode_close
static av_cold int encode_close(AVCodecContext *avc_context)
Definition: libtheoraenc.c:357
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
message
Definition: api-threadmessage-test.c:46
AV_CODEC_FLAG_QSCALE
#define AV_CODEC_FLAG_QSCALE
Use fixed qscale.
Definition: avcodec.h:210
TheoraContext::stats
uint8_t * stats
Definition: libtheoraenc.c:48
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:303
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:26
pixdesc.h
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:373
encode.h
TheoraContext::stats_offset
int stats_offset
Definition: libtheoraenc.c:50
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:425
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:31
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:459
av_pix_fmt_get_chroma_sub_sample
int av_pix_fmt_get_chroma_sub_sample(enum AVPixelFormat pix_fmt, int *h_shift, int *v_shift)
Utility function to access log2_chroma_w log2_chroma_h from the pixel format AVPixFmtDescriptor.
Definition: pixdesc.c:2568
AVRational::num
int num
Numerator.
Definition: rational.h:59
ogg_packet
static int ogg_packet(AVFormatContext *s, int *sid, int *dstart, int *dsize, int64_t *fpos)
find the next Ogg packet
Definition: oggdec.c:498
ff_libtheora_encoder
const AVCodec ff_libtheora_encoder
AVCodec struct exposed to libavcodec.
Definition: libtheoraenc.c:370
gop_size
int gop_size
Definition: movenc.c:67
AVCodecContext::color_primaries
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:942
pkt
AVPacket * pkt
Definition: movenc.c:59
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
av_cold
#define av_cold
Definition: attributes.h:90
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:481
av_fast_realloc
void * av_fast_realloc(void *ptr, unsigned int *size, size_t min_size)
Reallocate the given buffer if it is not large enough, otherwise do nothing.
Definition: mem.c:484
intreadwrite.h
AVCodecContext::stats_in
char * stats_in
pass2 encoding statistics input buffer Concatenated stuff from stats_out of pass1 should be placed he...
Definition: avcodec.h:1240
AVCodecContext::global_quality
int global_quality
Global quality for codecs which cannot change it per frame.
Definition: avcodec.h:445
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:290
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
AVCOL_PRI_BT470BG
@ AVCOL_PRI_BT470BG
also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM
Definition: pixfmt.h:455
TheoraContext
Definition: libtheoraenc.c:46
result
and forward the result(frame or status change) to the corresponding input. If nothing is possible
NULL
#define NULL
Definition: coverity.c:32
TheoraContext::stats_size
int stats_size
Definition: libtheoraenc.c:49
TheoraContext::t_state
th_enc_ctx * t_state
Definition: libtheoraenc.c:47
AV_WB16
#define AV_WB16(p, v)
Definition: intreadwrite.h:405
AVCodecContext::bit_rate
int64_t bit_rate
the average bitrate
Definition: avcodec.h:429
av_clipf
#define av_clipf
Definition: common.h:144
encode_frame
static int encode_frame(AVCodecContext *avc_context, AVPacket *pkt, const AVFrame *frame, int *got_packet)
Definition: libtheoraenc.c:276
av_base64_decode
int av_base64_decode(uint8_t *out, const char *in_str, int out_size)
Decode a base64-encoded string.
Definition: base64.c:79
base64.h
AVCodecContext::time_base
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
Definition: avcodec.h:502
AVCodecContext::stats_out
char * stats_out
pass1 encoding statistics output buffer
Definition: avcodec.h:1232
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:116
AVCodecContext::gop_size
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition: avcodec.h:574
av_reallocp
int av_reallocp(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory through a pointer to a pointer.
Definition: mem.c:167
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:372
AV_CODEC_FLAG_PASS2
#define AV_CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
Definition: avcodec.h:235
AVERROR_EXTERNAL
#define AVERROR_EXTERNAL
Generic error in an external library.
Definition: error.h:59
offset
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Definition: writing_filters.txt:86
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:379
AV_BASE64_SIZE
#define AV_BASE64_SIZE(x)
Calculate the output size needed to base64-encode x bytes to a null-terminated string.
Definition: base64.h:66
i
int i
Definition: input.c:406
log.h
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:366
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:480
AV_CODEC_ID_THEORA
@ AV_CODEC_ID_THEORA
Definition: codec_id.h:80
common.h
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:204
concatenate_packet
static int concatenate_packet(unsigned int *offset, AVCodecContext *avc_context, const ogg_packet *packet)
Concatenate an ogg_packet into the extradata.
Definition: libtheoraenc.c:57
AVCodecContext::height
int height
Definition: avcodec.h:552
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:589
avcodec.h
AVCOL_PRI_BT470M
@ AVCOL_PRI_BT470M
also FCC Title 47 Code of Federal Regulations 73.682 (a)(20)
Definition: pixfmt.h:453
ret
ret
Definition: filter_design.txt:187
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
encode_init
static av_cold int encode_init(AVCodecContext *avc_context)
Definition: libtheoraenc.c:165
AVCodecContext
main external API structure.
Definition: avcodec.h:379
TheoraContext::uv_hshift
int uv_hshift
Definition: libtheoraenc.c:51
ff_get_encode_buffer
int ff_get_encode_buffer(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int flags)
Get a buffer for a packet.
Definition: encode.c:78
AVRational::den
int den
Denominator.
Definition: rational.h:60
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
get_stats
static int get_stats(AVCodecContext *avctx, int eos)
Definition: libtheoraenc.c:90
av_base64_encode
char * av_base64_encode(char *out, int out_size, const uint8_t *in, int in_size)
Encode data to base64 and null-terminate.
Definition: base64.c:143
AV_CODEC_CAP_DELAY
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
Definition: codec.h:77
submit_stats
static int submit_stats(AVCodecContext *avctx)
Definition: libtheoraenc.c:128
AV_PIX_FMT_YUV444P
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:71
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AV_PIX_FMT_YUV422P
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:70
message
static int FUNC() message(CodedBitstreamContext *ctx, RWContext *rw, SEIRawMessage *current)
Definition: cbs_sei_syntax_template.c:147
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
AVPacket
This structure stores compressed data.
Definition: packet.h:350
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:406
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:552
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
h
h
Definition: vp9dsp_template.c:2038
FF_QP2LAMBDA
#define FF_QP2LAMBDA
factor to convert from H.263 QP to lambda
Definition: avutil.h:227
TheoraContext::keyframe_mask
int keyframe_mask
Definition: libtheoraenc.c:53
AVCodecContext::sample_aspect_ratio
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel.
Definition: avcodec.h:749
AV_CODEC_FLAG_PASS1
#define AV_CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
Definition: avcodec.h:231