FFmpeg
hapenc.c
Go to the documentation of this file.
1 /*
2  * Vidvox Hap encoder
3  * Copyright (C) 2015 Vittorio Giovara <vittorio.giovara@gmail.com>
4  * Copyright (C) 2015 Tom Butterworth <bangnoise@gmail.com>
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
23 /**
24  * @file
25  * Hap encoder
26  *
27  * Fourcc: Hap1, Hap5, HapY
28  *
29  * https://github.com/Vidvox/hap/blob/master/documentation/HapVideoDRAFT.md
30  */
31 
32 #include <stdint.h>
33 #include "snappy-c.h"
34 
35 #include "libavutil/frame.h"
36 #include "libavutil/imgutils.h"
37 #include "libavutil/mem.h"
38 #include "libavutil/opt.h"
39 
40 #include "avcodec.h"
41 #include "bytestream.h"
42 #include "codec_internal.h"
43 #include "encode.h"
44 #include "hap.h"
45 #include "texturedsp.h"
46 
47 #define HAP_MAX_CHUNKS 64
48 
50  /* Short header: four bytes with a 24 bit size value */
52  /* Long header: eight bytes with a 32 bit size value */
54 };
55 
56 static int compress_texture(AVCodecContext *avctx, uint8_t *out, int out_length, const AVFrame *f)
57 {
58  HapContext *ctx = avctx->priv_data;
59 
60  if (ctx->tex_size > out_length)
62 
63  ctx->enc.tex_data.out = out;
64  ctx->enc.frame_data.in = f->data[0];
65  ctx->enc.stride = f->linesize[0];
66  ctx->enc.width = avctx->width;
67  ctx->enc.height = avctx->height;
69 
70  return 0;
71 }
72 
73 /* section_length does not include the header */
75  enum HapHeaderLength header_length,
76  int section_length,
77  enum HapSectionType section_type)
78 {
79  /* The first three bytes are the length of the section (not including the
80  * header) or zero if using an eight-byte header.
81  * For an eight-byte header, the length is in the last four bytes.
82  * The fourth byte stores the section type. */
83  bytestream2_put_le24(pbc, header_length == HAP_HDR_LONG ? 0 : section_length);
84  bytestream2_put_byte(pbc, section_type);
85 
86  if (header_length == HAP_HDR_LONG) {
87  bytestream2_put_le32(pbc, section_length);
88  }
89 }
90 
91 static int hap_compress_frame(AVCodecContext *avctx, uint8_t *dst)
92 {
93  HapContext *ctx = avctx->priv_data;
94  int i, final_size = 0;
95 
96  for (i = 0; i < ctx->chunk_count; i++) {
97  HapChunk *chunk = &ctx->chunks[i];
98  uint8_t *chunk_src, *chunk_dst;
99  int ret;
100 
101  if (i == 0) {
102  chunk->compressed_offset = 0;
103  } else {
104  chunk->compressed_offset = ctx->chunks[i-1].compressed_offset
105  + ctx->chunks[i-1].compressed_size;
106  }
107  chunk->uncompressed_size = ctx->tex_size / ctx->chunk_count;
108  chunk->uncompressed_offset = i * chunk->uncompressed_size;
109  chunk->compressed_size = ctx->max_snappy;
110  chunk_src = ctx->tex_buf + chunk->uncompressed_offset;
111  chunk_dst = dst + chunk->compressed_offset;
112 
113  /* Compress with snappy too, write directly on packet buffer. */
114  ret = snappy_compress(chunk_src, chunk->uncompressed_size,
115  chunk_dst, &chunk->compressed_size);
116  if (ret != SNAPPY_OK) {
117  av_log(avctx, AV_LOG_ERROR, "Snappy compress error.\n");
118  return AVERROR_BUG;
119  }
120 
121  /* If there is no gain from snappy, just use the raw texture. */
122  if (chunk->compressed_size >= chunk->uncompressed_size) {
123  av_log(avctx, AV_LOG_VERBOSE,
124  "Snappy buffer bigger than uncompressed (%"SIZE_SPECIFIER" >= %"SIZE_SPECIFIER" bytes).\n",
125  chunk->compressed_size, chunk->uncompressed_size);
126  memcpy(chunk_dst, chunk_src, chunk->uncompressed_size);
127  chunk->compressor = HAP_COMP_NONE;
128  chunk->compressed_size = chunk->uncompressed_size;
129  } else {
130  chunk->compressor = HAP_COMP_SNAPPY;
131  }
132 
133  final_size += chunk->compressed_size;
134  }
135 
136  return final_size;
137 }
138 
140 {
141  /* Second-Stage Compressor Table (one byte per entry)
142  * + Chunk Size Table (four bytes per entry)
143  * + headers for both sections (short versions)
144  * = chunk_count + (4 * chunk_count) + 4 + 4 */
145  return (5 * ctx->chunk_count) + 8;
146 }
147 
149 {
150  /* Top section header (long version) */
151  int length = HAP_HDR_LONG;
152 
153  if (ctx->chunk_count > 1) {
154  /* Decode Instructions header (short) + Decode Instructions Container */
156  }
157 
158  return length;
159 }
160 
161 static void hap_write_frame_header(HapContext *ctx, uint8_t *dst, int frame_length)
162 {
163  PutByteContext pbc;
164  int i;
165 
166  bytestream2_init_writer(&pbc, dst, frame_length);
167  if (ctx->chunk_count == 1) {
168  /* Write a simple header */
169  hap_write_section_header(&pbc, HAP_HDR_LONG, frame_length - 8,
170  ctx->chunks[0].compressor | ctx->opt_tex_fmt);
171  } else {
172  /* Write a complex header with Decode Instructions Container */
173  hap_write_section_header(&pbc, HAP_HDR_LONG, frame_length - 8,
174  HAP_COMP_COMPLEX | ctx->opt_tex_fmt);
177  hap_write_section_header(&pbc, HAP_HDR_SHORT, ctx->chunk_count,
179 
180  for (i = 0; i < ctx->chunk_count; i++) {
181  bytestream2_put_byte(&pbc, ctx->chunks[i].compressor >> 4);
182  }
183 
184  hap_write_section_header(&pbc, HAP_HDR_SHORT, ctx->chunk_count * 4,
186 
187  for (i = 0; i < ctx->chunk_count; i++) {
188  bytestream2_put_le32(&pbc, ctx->chunks[i].compressed_size);
189  }
190  }
191 }
192 
193 static int hap_encode(AVCodecContext *avctx, AVPacket *pkt,
194  const AVFrame *frame, int *got_packet)
195 {
196  HapContext *ctx = avctx->priv_data;
197  int header_length = hap_header_length(ctx);
198  int final_data_size, ret;
199  int pktsize = FFMAX(ctx->tex_size, ctx->max_snappy * ctx->chunk_count) + header_length;
200 
201  /* Allocate maximum size packet, shrink later. */
202  ret = ff_alloc_packet(avctx, pkt, pktsize);
203  if (ret < 0)
204  return ret;
205 
206  if (ctx->opt_compressor == HAP_COMP_NONE) {
207  /* DXTC compression directly to the packet buffer. */
208  ret = compress_texture(avctx, pkt->data + header_length, pkt->size - header_length, frame);
209  if (ret < 0)
210  return ret;
211 
212  ctx->chunks[0].compressor = HAP_COMP_NONE;
213  final_data_size = ctx->tex_size;
214  } else {
215  /* DXTC compression. */
216  ret = compress_texture(avctx, ctx->tex_buf, ctx->tex_size, frame);
217  if (ret < 0)
218  return ret;
219 
220  /* Compress (using Snappy) the frame */
221  final_data_size = hap_compress_frame(avctx, pkt->data + header_length);
222  if (final_data_size < 0)
223  return final_data_size;
224  }
225 
226  /* Write header at the start. */
227  hap_write_frame_header(ctx, pkt->data, final_data_size + header_length);
228 
229  av_shrink_packet(pkt, final_data_size + header_length);
230  *got_packet = 1;
231  return 0;
232 }
233 
234 static av_cold int hap_init(AVCodecContext *avctx)
235 {
236  HapContext *ctx = avctx->priv_data;
238  int corrected_chunk_count;
239  int ret = av_image_check_size(avctx->width, avctx->height, 0, avctx);
240 
241  if (ret < 0) {
242  av_log(avctx, AV_LOG_ERROR, "Invalid video size %dx%d.\n",
243  avctx->width, avctx->height);
244  return ret;
245  }
246 
247  if (avctx->width % 4 || avctx->height % 4) {
248  av_log(avctx, AV_LOG_ERROR, "Video size %dx%d is not multiple of 4.\n",
249  avctx->width, avctx->height);
250  return AVERROR_INVALIDDATA;
251  }
252 
253  ff_texturedspenc_init(&dxtc);
254 
255  switch (ctx->opt_tex_fmt) {
256  case HAP_FMT_RGBDXT1:
257  ctx->enc.tex_ratio = 8;
258  avctx->codec_tag = MKTAG('H', 'a', 'p', '1');
259  avctx->bits_per_coded_sample = 24;
260  ctx->enc.tex_funct = dxtc.dxt1_block;
261  break;
262  case HAP_FMT_RGBADXT5:
263  ctx->enc.tex_ratio = 16;
264  avctx->codec_tag = MKTAG('H', 'a', 'p', '5');
265  avctx->bits_per_coded_sample = 32;
266  ctx->enc.tex_funct = dxtc.dxt5_block;
267  break;
268  case HAP_FMT_YCOCGDXT5:
269  ctx->enc.tex_ratio = 16;
270  avctx->codec_tag = MKTAG('H', 'a', 'p', 'Y');
271  avctx->bits_per_coded_sample = 24;
272  ctx->enc.tex_funct = dxtc.dxt5ys_block;
273  break;
274  default:
275  av_log(avctx, AV_LOG_ERROR, "Invalid format %02X\n", ctx->opt_tex_fmt);
276  return AVERROR_INVALIDDATA;
277  }
278  ctx->enc.raw_ratio = 16;
279  ctx->enc.slice_count = av_clip(avctx->thread_count, 1, avctx->height / TEXTURE_BLOCK_H);
280 
281  /* Texture compression ratio is constant, so can we computer
282  * beforehand the final size of the uncompressed buffer. */
283  ctx->tex_size = avctx->width / TEXTURE_BLOCK_W *
284  avctx->height / TEXTURE_BLOCK_H * ctx->enc.tex_ratio;
285 
286  switch (ctx->opt_compressor) {
287  case HAP_COMP_NONE:
288  /* No benefit chunking uncompressed data */
289  corrected_chunk_count = 1;
290 
291  ctx->max_snappy = ctx->tex_size;
292  ctx->tex_buf = NULL;
293  break;
294  case HAP_COMP_SNAPPY:
295  /* Round the chunk count to divide evenly on DXT block edges */
296  corrected_chunk_count = av_clip(ctx->opt_chunk_count, 1, HAP_MAX_CHUNKS);
297  while ((ctx->tex_size / ctx->enc.tex_ratio) % corrected_chunk_count != 0) {
298  corrected_chunk_count--;
299  }
300 
301  ctx->max_snappy = snappy_max_compressed_length(ctx->tex_size / corrected_chunk_count);
302  ctx->tex_buf = av_malloc(ctx->tex_size);
303  if (!ctx->tex_buf) {
304  return AVERROR(ENOMEM);
305  }
306  break;
307  default:
308  av_log(avctx, AV_LOG_ERROR, "Invalid compresor %02X\n", ctx->opt_compressor);
309  return AVERROR_INVALIDDATA;
310  }
311  if (corrected_chunk_count != ctx->opt_chunk_count) {
312  av_log(avctx, AV_LOG_INFO, "%d chunks requested but %d used.\n",
313  ctx->opt_chunk_count, corrected_chunk_count);
314  }
315  ret = ff_hap_set_chunk_count(ctx, corrected_chunk_count, 1);
316  if (ret != 0)
317  return ret;
318 
319  return 0;
320 }
321 
322 static av_cold int hap_close(AVCodecContext *avctx)
323 {
324  HapContext *ctx = avctx->priv_data;
325 
327 
328  return 0;
329 }
330 
331 #define OFFSET(x) offsetof(HapContext, x)
332 #define FLAGS AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
333 static const AVOption options[] = {
334  { "format", NULL, OFFSET(opt_tex_fmt), AV_OPT_TYPE_INT, { .i64 = HAP_FMT_RGBDXT1 }, HAP_FMT_RGBDXT1, HAP_FMT_YCOCGDXT5, FLAGS, .unit = "format" },
335  { "hap", "Hap 1 (DXT1 textures)", 0, AV_OPT_TYPE_CONST, { .i64 = HAP_FMT_RGBDXT1 }, 0, 0, FLAGS, .unit = "format" },
336  { "hap_alpha", "Hap Alpha (DXT5 textures)", 0, AV_OPT_TYPE_CONST, { .i64 = HAP_FMT_RGBADXT5 }, 0, 0, FLAGS, .unit = "format" },
337  { "hap_q", "Hap Q (DXT5-YCoCg textures)", 0, AV_OPT_TYPE_CONST, { .i64 = HAP_FMT_YCOCGDXT5 }, 0, 0, FLAGS, .unit = "format" },
338  { "chunks", "chunk count", OFFSET(opt_chunk_count), AV_OPT_TYPE_INT, {.i64 = 1 }, 1, HAP_MAX_CHUNKS, FLAGS, },
339  { "compressor", "second-stage compressor", OFFSET(opt_compressor), AV_OPT_TYPE_INT, { .i64 = HAP_COMP_SNAPPY }, HAP_COMP_NONE, HAP_COMP_SNAPPY, FLAGS, .unit = "compressor" },
340  { "none", "None", 0, AV_OPT_TYPE_CONST, { .i64 = HAP_COMP_NONE }, 0, 0, FLAGS, .unit = "compressor" },
341  { "snappy", "Snappy", 0, AV_OPT_TYPE_CONST, { .i64 = HAP_COMP_SNAPPY }, 0, 0, FLAGS, .unit = "compressor" },
342  { NULL },
343 };
344 
345 static const AVClass hapenc_class = {
346  .class_name = "Hap encoder",
347  .item_name = av_default_item_name,
348  .option = options,
349  .version = LIBAVUTIL_VERSION_INT,
350 };
351 
353  .p.name = "hap",
354  CODEC_LONG_NAME("Vidvox Hap"),
355  .p.type = AVMEDIA_TYPE_VIDEO,
356  .p.id = AV_CODEC_ID_HAP,
357  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_SLICE_THREADS |
359  .priv_data_size = sizeof(HapContext),
360  .p.priv_class = &hapenc_class,
361  .init = hap_init,
363  .close = hap_close,
364  .p.pix_fmts = (const enum AVPixelFormat[]) {
366  },
367  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
368 };
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
HAP_FMT_YCOCGDXT5
@ HAP_FMT_YCOCGDXT5
Definition: hap.h:35
av_clip
#define av_clip
Definition: common.h:100
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: codec_internal.h:42
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
opt.h
TEXTURE_BLOCK_H
#define TEXTURE_BLOCK_H
Definition: texturedsp.h:43
out
FILE * out
Definition: movenc.c:55
OFFSET
#define OFFSET(x)
Definition: hapenc.c:331
HapChunk::compressed_size
size_t compressed_size
Definition: hap.h:55
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:374
AVPacket::data
uint8_t * data
Definition: packet.h:520
TextureDSPEncContext
Definition: texturedsp.h:63
AVOption
AVOption.
Definition: opt.h:357
encode.h
FFCodec
Definition: codec_internal.h:126
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
hap_compress_frame
static int hap_compress_frame(AVCodecContext *avctx, uint8_t *dst)
Definition: hapenc.c:91
HapContext
Definition: hap.h:60
hapenc_class
static const AVClass hapenc_class
Definition: hapenc.c:345
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
HapHeaderLength
HapHeaderLength
Definition: hapenc.c:49
hap_init
static av_cold int hap_init(AVCodecContext *avctx)
Definition: hapenc.c:234
texturedsp.h
ff_texturedspenc_init
void ff_texturedspenc_init(TextureDSPEncContext *c)
Definition: texturedspenc.c:650
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:130
AVCodecContext::thread_count
int thread_count
thread count is used to decide how many independent tasks should be passed to execute()
Definition: avcodec.h:1583
hap.h
av_shrink_packet
void av_shrink_packet(AVPacket *pkt, int size)
Reduce packet size, correctly zeroing padding.
Definition: packet.c:113
AVERROR_BUFFER_TOO_SMALL
#define AVERROR_BUFFER_TOO_SMALL
Buffer too small.
Definition: error.h:53
hap_close
static av_cold int hap_close(AVCodecContext *avctx)
Definition: hapenc.c:322
FF_CODEC_ENCODE_CB
#define FF_CODEC_ENCODE_CB(func)
Definition: codec_internal.h:295
HAP_FMT_RGBADXT5
@ HAP_FMT_RGBADXT5
Definition: hap.h:34
HAP_COMP_SNAPPY
@ HAP_COMP_SNAPPY
Definition: hap.h:41
HAP_COMP_NONE
@ HAP_COMP_NONE
Definition: hap.h:40
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
hap_write_section_header
static void hap_write_section_header(PutByteContext *pbc, enum HapHeaderLength header_length, int section_length, enum HapSectionType section_type)
Definition: hapenc.c:74
bytestream2_init_writer
static av_always_inline void bytestream2_init_writer(PutByteContext *p, uint8_t *buf, int buf_size)
Definition: bytestream.h:147
ff_hap_free_context
av_cold void ff_hap_free_context(HapContext *ctx)
Definition: hap.c:51
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
HAP_ST_SIZE_TABLE
@ HAP_ST_SIZE_TABLE
Definition: hap.h:48
ctx
AVFormatContext * ctx
Definition: movenc.c:49
ff_hap_encoder
const FFCodec ff_hap_encoder
Definition: hapenc.c:352
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:271
AV_PIX_FMT_RGBA
@ AV_PIX_FMT_RGBA
packed RGBA 8:8:8:8, 32bpp, RGBARGBA...
Definition: pixfmt.h:100
HAP_HDR_SHORT
@ HAP_HDR_SHORT
Definition: hapenc.c:51
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
NULL
#define NULL
Definition: coverity.c:32
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
HAP_ST_DECODE_INSTRUCTIONS
@ HAP_ST_DECODE_INSTRUCTIONS
Definition: hap.h:46
options
static const AVOption options[]
Definition: hapenc.c:333
HAP_COMP_COMPLEX
@ HAP_COMP_COMPLEX
Definition: hap.h:42
ff_hap_set_chunk_count
int ff_hap_set_chunk_count(HapContext *ctx, int count, int first_in_frame)
Definition: hap.c:29
HapChunk::uncompressed_size
size_t uncompressed_size
Definition: hap.h:57
PutByteContext
Definition: bytestream.h:37
HapSectionType
HapSectionType
Definition: hap.h:45
f
f
Definition: af_crystalizer.c:121
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
AVPacket::size
int size
Definition: packet.h:521
codec_internal.h
HapChunk::compressor
enum HapCompressor compressor
Definition: hap.h:53
hap_write_frame_header
static void hap_write_frame_header(HapContext *ctx, uint8_t *dst, int frame_length)
Definition: hapenc.c:161
ff_texturedsp_exec_compress_threads
int ff_texturedsp_exec_compress_threads(struct AVCodecContext *avctx, TextureDSPThreadContext *ctx)
frame.h
AV_CODEC_CAP_SLICE_THREADS
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: codec.h:114
FLAGS
#define FLAGS
Definition: hapenc.c:332
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:191
AVCodecContext::bits_per_coded_sample
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:1568
HAP_ST_COMPRESSOR_TABLE
@ HAP_ST_COMPRESSOR_TABLE
Definition: hap.h:47
HapChunk
Definition: hap.h:52
HapChunk::uncompressed_offset
int uncompressed_offset
Definition: hap.h:56
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
TEXTURE_BLOCK_W
#define TEXTURE_BLOCK_W
Definition: texturedsp.h:42
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
TextureDSPEncContext::dxt5ys_block
int(* dxt5ys_block)(uint8_t *dst, ptrdiff_t stride, const uint8_t *block)
Definition: texturedsp.h:66
AVCodecContext::height
int height
Definition: avcodec.h:618
avcodec.h
ret
ret
Definition: filter_design.txt:187
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:71
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
hap_encode
static int hap_encode(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *frame, int *got_packet)
Definition: hapenc.c:193
HAP_MAX_CHUNKS
#define HAP_MAX_CHUNKS
Definition: hapenc.c:47
SIZE_SPECIFIER
#define SIZE_SPECIFIER
Definition: internal.h:129
AVCodecContext
main external API structure.
Definition: avcodec.h:445
AV_CODEC_ID_HAP
@ AV_CODEC_ID_HAP
Definition: codec_id.h:241
TextureDSPEncContext::dxt1_block
int(* dxt1_block)(uint8_t *dst, ptrdiff_t stride, const uint8_t *block)
Definition: texturedsp.h:64
hap_decode_instructions_length
static int hap_decode_instructions_length(HapContext *ctx)
Definition: hapenc.c:139
HAP_FMT_RGBDXT1
@ HAP_FMT_RGBDXT1
Definition: hap.h:33
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:245
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
mem.h
HAP_HDR_LONG
@ HAP_HDR_LONG
Definition: hapenc.c:53
AVCodecContext::codec_tag
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
Definition: avcodec.h:470
AVPacket
This structure stores compressed data.
Definition: packet.h:497
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:472
HapChunk::compressed_offset
uint32_t compressed_offset
Definition: hap.h:54
hap_header_length
static int hap_header_length(HapContext *ctx)
Definition: hapenc.c:148
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:618
bytestream.h
imgutils.h
AVERROR_BUG
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Definition: error.h:52
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
TextureDSPEncContext::dxt5_block
int(* dxt5_block)(uint8_t *dst, ptrdiff_t stride, const uint8_t *block)
Definition: texturedsp.h:65
MKTAG
#define MKTAG(a, b, c, d)
Definition: macros.h:55
av_image_check_size
int av_image_check_size(unsigned int w, unsigned int h, int log_offset, void *log_ctx)
Check if the given dimension of an image is valid, meaning that all bytes of the image can be address...
Definition: imgutils.c:318
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:254
ff_alloc_packet
int ff_alloc_packet(AVCodecContext *avctx, AVPacket *avpkt, int64_t size)
Check AVPacket size and allocate data.
Definition: encode.c:62
compress_texture
static int compress_texture(AVCodecContext *avctx, uint8_t *out, int out_length, const AVFrame *f)
Definition: hapenc.c:56