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/mem.h"
37 #include "libavutil/pixdesc.h"
38 #include "libavutil/log.h"
39 #include "libavutil/base64.h"
40 #include "avcodec.h"
41 #include "codec_internal.h"
42 #include "encode.h"
43 
44 /* libtheora includes */
45 #include <theora/theoraenc.h>
46 
47 typedef struct TheoraContext {
48  th_enc_ctx *t_state;
49  uint8_t *stats;
52  int uv_hshift;
53  int uv_vshift;
56 
57 /** Concatenate an ogg_packet into the extradata. */
58 static int concatenate_packet(unsigned int* offset,
59  AVCodecContext* avc_context,
60  const ogg_packet* packet)
61 {
62  const char* message = NULL;
63  int newsize = avc_context->extradata_size + 2 + packet->bytes;
64  int err = AVERROR_INVALIDDATA;
65 
66  if (packet->bytes < 0) {
67  message = "ogg_packet has negative size";
68  } else if (packet->bytes > 0xffff) {
69  message = "ogg_packet is larger than 65535 bytes";
70  } else if (newsize < avc_context->extradata_size) {
71  message = "extradata_size would overflow";
72  } else {
73  if ((err = av_reallocp(&avc_context->extradata, newsize)) < 0) {
74  avc_context->extradata_size = 0;
75  message = "av_realloc failed";
76  }
77  }
78  if (message) {
79  av_log(avc_context, AV_LOG_ERROR, "concatenate_packet failed: %s\n", message);
80  return err;
81  }
82 
83  avc_context->extradata_size = newsize;
84  AV_WB16(avc_context->extradata + (*offset), packet->bytes);
85  *offset += 2;
86  memcpy(avc_context->extradata + (*offset), packet->packet, packet->bytes);
87  (*offset) += packet->bytes;
88  return 0;
89 }
90 
91 static int get_stats(AVCodecContext *avctx, int eos)
92 {
93 #ifdef TH_ENCCTL_2PASS_OUT
94  TheoraContext *h = avctx->priv_data;
95  uint8_t *buf;
96  int bytes;
97 
98  bytes = th_encode_ctl(h->t_state, TH_ENCCTL_2PASS_OUT, &buf, sizeof(buf));
99  if (bytes < 0) {
100  av_log(avctx, AV_LOG_ERROR, "Error getting first pass stats\n");
101  return AVERROR_EXTERNAL;
102  }
103  if (!eos) {
104  void *tmp = av_fast_realloc(h->stats, &h->stats_size,
105  h->stats_offset + bytes);
106  if (!tmp)
107  return AVERROR(ENOMEM);
108  h->stats = tmp;
109  memcpy(h->stats + h->stats_offset, buf, bytes);
110  h->stats_offset += bytes;
111  } else {
112  int b64_size = AV_BASE64_SIZE(h->stats_offset);
113  // libtheora generates a summary header at the end
114  memcpy(h->stats, buf, bytes);
115  avctx->stats_out = av_malloc(b64_size);
116  if (!avctx->stats_out)
117  return AVERROR(ENOMEM);
118  av_base64_encode(avctx->stats_out, b64_size, h->stats, h->stats_offset);
119  }
120  return 0;
121 #else
122  av_log(avctx, AV_LOG_ERROR, "libtheora too old to support 2pass\n");
123  return AVERROR(ENOTSUP);
124 #endif
125 }
126 
127 // libtheora won't read the entire buffer we give it at once, so we have to
128 // repeatedly submit it...
129 static int submit_stats(AVCodecContext *avctx)
130 {
131 #ifdef TH_ENCCTL_2PASS_IN
132  TheoraContext *h = avctx->priv_data;
133  int bytes;
134  if (!h->stats) {
135  if (!avctx->stats_in) {
136  av_log(avctx, AV_LOG_ERROR, "No statsfile for second pass\n");
137  return AVERROR(EINVAL);
138  }
139  h->stats_size = strlen(avctx->stats_in) * 3/4;
140  h->stats = av_malloc(h->stats_size);
141  if (!h->stats) {
142  h->stats_size = 0;
143  return AVERROR(ENOMEM);
144  }
145  h->stats_size = av_base64_decode(h->stats, avctx->stats_in, h->stats_size);
146  }
147  while (h->stats_size - h->stats_offset > 0) {
148  bytes = th_encode_ctl(h->t_state, TH_ENCCTL_2PASS_IN,
149  h->stats + h->stats_offset,
150  h->stats_size - h->stats_offset);
151  if (bytes < 0) {
152  av_log(avctx, AV_LOG_ERROR, "Error submitting stats\n");
153  return AVERROR_EXTERNAL;
154  }
155  if (!bytes)
156  return 0;
157  h->stats_offset += bytes;
158  }
159  return 0;
160 #else
161  av_log(avctx, AV_LOG_ERROR, "libtheora too old to support 2pass\n");
162  return AVERROR(ENOTSUP);
163 #endif
164 }
165 
166 static av_cold int encode_init(AVCodecContext* avc_context)
167 {
168  th_info t_info;
169  th_comment t_comment;
170  ogg_packet o_packet;
171  unsigned int offset;
172  TheoraContext *h = avc_context->priv_data;
173  uint32_t gop_size = avc_context->gop_size;
174  int ret;
175 
176  /* Set up the theora_info struct */
177  th_info_init(&t_info);
178  t_info.frame_width = FFALIGN(avc_context->width, 16);
179  t_info.frame_height = FFALIGN(avc_context->height, 16);
180  t_info.pic_width = avc_context->width;
181  t_info.pic_height = avc_context->height;
182  t_info.pic_x = 0;
183  t_info.pic_y = 0;
184  /* Swap numerator and denominator as time_base in AVCodecContext gives the
185  * time period between frames, but theora_info needs the framerate. */
186  t_info.fps_numerator = avc_context->time_base.den;
187  t_info.fps_denominator = avc_context->time_base.num;
188  if (avc_context->sample_aspect_ratio.num) {
189  t_info.aspect_numerator = avc_context->sample_aspect_ratio.num;
190  t_info.aspect_denominator = avc_context->sample_aspect_ratio.den;
191  } else {
192  t_info.aspect_numerator = 1;
193  t_info.aspect_denominator = 1;
194  }
195 
196  if (avc_context->color_primaries == AVCOL_PRI_BT470M)
197  t_info.colorspace = TH_CS_ITU_REC_470M;
198  else if (avc_context->color_primaries == AVCOL_PRI_BT470BG)
199  t_info.colorspace = TH_CS_ITU_REC_470BG;
200  else
201  t_info.colorspace = TH_CS_UNSPECIFIED;
202 
203  if (avc_context->pix_fmt == AV_PIX_FMT_YUV420P)
204  t_info.pixel_fmt = TH_PF_420;
205  else if (avc_context->pix_fmt == AV_PIX_FMT_YUV422P)
206  t_info.pixel_fmt = TH_PF_422;
207  else if (avc_context->pix_fmt == AV_PIX_FMT_YUV444P)
208  t_info.pixel_fmt = TH_PF_444;
209  else {
210  av_log(avc_context, AV_LOG_ERROR, "Unsupported pix_fmt\n");
211  return AVERROR(EINVAL);
212  }
213  ret = av_pix_fmt_get_chroma_sub_sample(avc_context->pix_fmt, &h->uv_hshift, &h->uv_vshift);
214  if (ret)
215  return ret;
216 
217  if (avc_context->flags & AV_CODEC_FLAG_QSCALE) {
218  /* Clip global_quality in QP units to the [0 - 10] range
219  to be consistent with the libvorbis implementation.
220  Theora accepts a quality parameter which is an int value in
221  the [0 - 63] range.
222  */
223  t_info.quality = av_clipf(avc_context->global_quality / (float)FF_QP2LAMBDA, 0, 10) * 6.3;
224  t_info.target_bitrate = 0;
225  } else {
226  t_info.target_bitrate = avc_context->bit_rate;
227  t_info.quality = 0;
228  }
229 
230  /* Now initialise libtheora */
231  h->t_state = th_encode_alloc(&t_info);
232  if (!h->t_state) {
233  av_log(avc_context, AV_LOG_ERROR, "theora_encode_init failed\n");
234  return AVERROR_EXTERNAL;
235  }
236 
237  h->keyframe_mask = (1 << t_info.keyframe_granule_shift) - 1;
238  /* Clear up theora_info struct */
239  th_info_clear(&t_info);
240 
241  if (th_encode_ctl(h->t_state, TH_ENCCTL_SET_KEYFRAME_FREQUENCY_FORCE,
242  &gop_size, sizeof(gop_size))) {
243  av_log(avc_context, AV_LOG_ERROR, "Error setting GOP size\n");
244  return AVERROR_EXTERNAL;
245  }
246 
247  // need to enable 2 pass (via TH_ENCCTL_2PASS_) before encoding headers
248  if (avc_context->flags & AV_CODEC_FLAG_PASS1) {
249  if ((ret = get_stats(avc_context, 0)) < 0)
250  return ret;
251  } else if (avc_context->flags & AV_CODEC_FLAG_PASS2) {
252  if ((ret = submit_stats(avc_context)) < 0)
253  return ret;
254  }
255 
256  /*
257  Output first header packet consisting of theora
258  header, comment, and tables.
259 
260  Each one is prefixed with a 16-bit size, then they
261  are concatenated together into libavcodec's extradata.
262  */
263  offset = 0;
264 
265  /* Headers */
266  th_comment_init(&t_comment);
267 
268  while (th_encode_flushheader(h->t_state, &t_comment, &o_packet))
269  if ((ret = concatenate_packet(&offset, avc_context, &o_packet)) < 0)
270  return ret;
271 
272  th_comment_clear(&t_comment);
273 
274  return 0;
275 }
276 
277 static int encode_frame(AVCodecContext* avc_context, AVPacket *pkt,
278  const AVFrame *frame, int *got_packet)
279 {
280  th_ycbcr_buffer t_yuv_buffer;
281  TheoraContext *h = avc_context->priv_data;
282  ogg_packet o_packet;
283  int result, i, ret;
284 
285  // EOS, finish and get 1st pass stats if applicable
286  if (!frame) {
287  th_encode_packetout(h->t_state, 1, &o_packet);
288  if (avc_context->flags & AV_CODEC_FLAG_PASS1)
289  if ((ret = get_stats(avc_context, 1)) < 0)
290  return ret;
291  return 0;
292  }
293 
294  /* Copy planes to the theora yuv_buffer */
295  for (i = 0; i < 3; i++) {
296  t_yuv_buffer[i].width = FFALIGN(avc_context->width, 16) >> (i && h->uv_hshift);
297  t_yuv_buffer[i].height = FFALIGN(avc_context->height, 16) >> (i && h->uv_vshift);
298  t_yuv_buffer[i].stride = frame->linesize[i];
299  t_yuv_buffer[i].data = frame->data[i];
300  }
301 
302  if (avc_context->flags & AV_CODEC_FLAG_PASS2)
303  if ((ret = submit_stats(avc_context)) < 0)
304  return ret;
305 
306  /* Now call into theora_encode_YUVin */
307  result = th_encode_ycbcr_in(h->t_state, t_yuv_buffer);
308  if (result) {
309  const char* message;
310  switch (result) {
311  case -1:
312  message = "differing frame sizes";
313  break;
314  case TH_EINVAL:
315  message = "encoder is not ready or is finished";
316  break;
317  default:
318  message = "unknown reason";
319  break;
320  }
321  av_log(avc_context, AV_LOG_ERROR, "theora_encode_YUVin failed (%s) [%d]\n", message, result);
322  return AVERROR_EXTERNAL;
323  }
324 
325  if (avc_context->flags & AV_CODEC_FLAG_PASS1)
326  if ((ret = get_stats(avc_context, 0)) < 0)
327  return ret;
328 
329  /* Pick up returned ogg_packet */
330  result = th_encode_packetout(h->t_state, 0, &o_packet);
331  switch (result) {
332  case 0:
333  /* No packet is ready */
334  return 0;
335  case 1:
336  /* Success, we have a packet */
337  break;
338  default:
339  av_log(avc_context, AV_LOG_ERROR, "theora_encode_packetout failed [%d]\n", result);
340  return AVERROR_EXTERNAL;
341  }
342 
343  /* Copy ogg_packet content out to buffer */
344  if ((ret = ff_get_encode_buffer(avc_context, pkt, o_packet.bytes, 0)) < 0)
345  return ret;
346  memcpy(pkt->data, o_packet.packet, o_packet.bytes);
347 
348  // HACK: assumes no encoder delay, this is true until libtheora becomes
349  // multithreaded (which will be disabled unless explicitly requested)
350  pkt->pts = frame->pts;
351  pkt->duration = frame->duration;
352 
353  ret = ff_encode_reordered_opaque(avc_context, pkt, frame);
354  if (ret < 0)
355  return ret;
356 
357  if (!(o_packet.granulepos & h->keyframe_mask))
359  *got_packet = 1;
360 
361  return 0;
362 }
363 
364 static av_cold int encode_close(AVCodecContext* avc_context)
365 {
366  TheoraContext *h = avc_context->priv_data;
367 
368  th_encode_free(h->t_state);
369  av_freep(&h->stats);
370  av_freep(&avc_context->stats_out);
371  avc_context->extradata_size = 0;
372 
373  return 0;
374 }
375 
376 /** AVCodec struct exposed to libavcodec */
378  .p.name = "libtheora",
379  CODEC_LONG_NAME("libtheora Theora"),
380  .p.type = AVMEDIA_TYPE_VIDEO,
381  .p.id = AV_CODEC_ID_THEORA,
382  .p.capabilities = AV_CODEC_CAP_DR1 |
383  /* for statsfile summary */
386  .caps_internal = FF_CODEC_CAP_NOT_INIT_THREADSAFE,
387  .priv_data_size = sizeof(TheoraContext),
388  .init = encode_init,
389  .close = encode_close,
391  .p.pix_fmts = (const enum AVPixelFormat[]){
393  },
394  .p.wrapper_name = "libtheora",
395 };
ff_encode_reordered_opaque
int ff_encode_reordered_opaque(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *frame)
Propagate user opaque values from the frame to avctx/pkt as needed.
Definition: encode.c:235
TheoraContext::uv_vshift
int uv_vshift
Definition: libtheoraenc.c:53
encode_close
static av_cold int encode_close(AVCodecContext *avc_context)
Definition: libtheoraenc.c:364
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
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:47
AV_CODEC_FLAG_QSCALE
#define AV_CODEC_FLAG_QSCALE
Use fixed qscale.
Definition: avcodec.h:224
TheoraContext::stats
uint8_t * stats
Definition: libtheoraenc.c:49
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:374
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
pixdesc.h
AVPacket::data
uint8_t * data
Definition: packet.h:520
encode.h
FF_CODEC_CAP_NOT_INIT_THREADSAFE
#define FF_CODEC_CAP_NOT_INIT_THREADSAFE
The codec is not known to be init-threadsafe (i.e.
Definition: codec_internal.h:34
FFCodec
Definition: codec_internal.h:126
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:538
TheoraContext::stats_offset
int stats_offset
Definition: libtheoraenc.c:51
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:575
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:130
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:502
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:2993
FF_CODEC_ENCODE_CB
#define FF_CODEC_ENCODE_CB(func)
Definition: codec_internal.h:295
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:500
gop_size
int gop_size
Definition: movenc.c:68
AVCodecContext::color_primaries
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:671
pkt
AVPacket * pkt
Definition: movenc.c:60
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:524
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:497
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:1342
AVCodecContext::global_quality
int global_quality
Global quality for codecs which cannot change it per frame.
Definition: avcodec.h:1239
AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE
#define AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE
This encoder can reorder user opaque values from input AVFrames and return them with corresponding ou...
Definition: codec.h:159
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:73
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:271
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:562
TheoraContext
Definition: libtheoraenc.c:47
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:50
TheoraContext::t_state
th_enc_ctx * t_state
Definition: libtheoraenc.c:48
AV_WB16
#define AV_WB16(p, v)
Definition: intreadwrite.h:399
AVCodecContext::bit_rate
int64_t bit_rate
the average bitrate
Definition: avcodec.h:495
encode_frame
static int encode_frame(AVCodecContext *avc_context, AVPacket *pkt, const AVFrame *frame, int *got_packet)
Definition: libtheoraenc.c:277
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:81
av_clipf
av_clipf
Definition: af_crystalizer.c:121
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:544
AVCodecContext::stats_out
char * stats_out
pass1 encoding statistics output buffer
Definition: avcodec.h:1334
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:366
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
AVCodecContext::gop_size
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition: avcodec.h:1031
codec_internal.h
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:188
AV_CODEC_FLAG_PASS2
#define AV_CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
Definition: avcodec.h:314
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:526
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
log.h
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:513
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:523
AV_CODEC_ID_THEORA
@ AV_CODEC_ID_THEORA
Definition: codec_id.h:82
ff_libtheora_encoder
const FFCodec ff_libtheora_encoder
AVCodec struct exposed to libavcodec.
Definition: libtheoraenc.c:377
common.h
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
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:58
AVCodecContext::height
int height
Definition: avcodec.h:618
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:657
avcodec.h
AVCOL_PRI_BT470M
@ AVCOL_PRI_BT470M
also FCC Title 47 Code of Federal Regulations 73.682 (a)(20)
Definition: pixfmt.h:560
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:166
AVCodecContext
main external API structure.
Definition: avcodec.h:445
TheoraContext::uv_hshift
int uv_hshift
Definition: libtheoraenc.c:52
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:106
AVRational::den
int den
Denominator.
Definition: rational.h:60
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
get_stats
static int get_stats(AVCodecContext *avctx, int eos)
Definition: libtheoraenc.c:91
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:147
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:76
submit_stats
static int submit_stats(AVCodecContext *avctx)
Definition: libtheoraenc.c:129
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:78
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:77
mem.h
message
static int FUNC() message(CodedBitstreamContext *ctx, RWContext *rw, SEIRawMessage *current)
Definition: cbs_sei_syntax_template.c:165
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
AVPacket
This structure stores compressed data.
Definition: packet.h:497
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:472
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:618
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
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:54
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:642
AV_CODEC_FLAG_PASS1
#define AV_CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
Definition: avcodec.h:310