Go to the documentation of this file.
31 #define MAX_RLE_BULK 127
33 #define MAX_RLE_REPEAT 128
35 #define MAX_RLE_SKIP 254
85 s->logical_width=avctx->
width;
89 if (avctx->
width % 4) {
93 s->logical_width = avctx->
width / 4;
114 if (!
s->skip_table || !
s->length_table || !
s->rlecode_table) {
119 if (!
s->previous_frame) {
124 s->max_buf_size =
s->logical_width*
s->avctx->height*
s->pixel_size*2
137 int width=
s->logical_width;
143 unsigned int skipcount;
150 int total_repeat_cost;
153 int lowest_bulk_cost;
154 int lowest_bulk_cost_index;
155 int sec_lowest_bulk_cost;
156 int sec_lowest_bulk_cost_index;
159 (
width - 1)*
s->pixel_size;
160 uint8_t *prev_line =
s->previous_frame->data[0] +
line *
s->previous_frame->linesize[0] +
161 (
width - 1)*
s->pixel_size;
163 s->length_table[
width] = 0;
167 lowest_bulk_cost = INT_MAX / 2;
168 lowest_bulk_cost_index =
width;
169 sec_lowest_bulk_cost = INT_MAX / 2;
170 sec_lowest_bulk_cost_index =
width;
172 base_bulk_cost = 1 +
s->pixel_size;
181 lowest_bulk_cost = sec_lowest_bulk_cost;
182 lowest_bulk_cost_index = sec_lowest_bulk_cost_index;
184 sec_lowest_bulk_cost = INT_MAX / 2;
185 sec_lowest_bulk_cost_index =
width;
192 sec_lowest_bulk_cost++;
197 prev_bulk_cost =
s->length_table[
i + 1] + base_bulk_cost;
198 if (prev_bulk_cost <= sec_lowest_bulk_cost) {
201 if (prev_bulk_cost <= lowest_bulk_cost) {
206 sec_lowest_bulk_cost = INT_MAX / 2;
208 lowest_bulk_cost = prev_bulk_cost;
209 lowest_bulk_cost_index =
i + 1;
212 sec_lowest_bulk_cost = prev_bulk_cost;
213 sec_lowest_bulk_cost_index =
i + 1;
217 if (!
s->key_frame && !memcmp(this_line, prev_line,
s->pixel_size))
222 total_skip_cost =
s->length_table[
i + skipcount] + 2;
223 s->skip_table[
i] = skipcount;
226 if (
i <
width - 1 && !memcmp(this_line, this_line +
s->pixel_size,
s->pixel_size))
231 total_repeat_cost =
s->length_table[
i + repeatcount] + 1 +
s->pixel_size;
240 if (repeatcount > 1 && (skipcount == 0 || total_repeat_cost < total_skip_cost)) {
242 s->length_table[
i] = total_repeat_cost;
243 s->rlecode_table[
i] = -repeatcount;
245 else if (skipcount > 0) {
247 s->length_table[
i] = total_skip_cost;
248 s->rlecode_table[
i] = 0;
254 s->length_table[
i] = lowest_bulk_cost;
255 s->rlecode_table[
i] = lowest_bulk_cost_index -
i;
260 lowest_bulk_cost +=
s->pixel_size;
261 sec_lowest_bulk_cost +=
s->pixel_size;
262 if (this_line >= p->
data[0] +
s->pixel_size)
263 this_line -=
s->pixel_size;
264 if (prev_line >=
s->previous_frame->data[0] +
s->pixel_size)
265 prev_line -=
s->pixel_size;
276 if (
s->rlecode_table[0] == 0) {
277 bytestream_put_byte(buf,
s->skip_table[0] + 1);
278 i +=
s->skip_table[0];
280 else bytestream_put_byte(buf, 1);
284 rlecode =
s->rlecode_table[
i];
285 bytestream_put_byte(buf, rlecode);
288 bytestream_put_byte(buf,
s->skip_table[
i] + 1);
289 i +=
s->skip_table[
i];
291 else if (rlecode > 0) {
298 for (j = 0; j < rlecode*
s->pixel_size; ++j)
299 bytestream_put_byte(buf, *(this_line +
i*
s->pixel_size + j) ^ 0xff);
310 for (j = 0; j <
s->pixel_size; ++j)
311 bytestream_put_byte(buf, *(this_line +
i*
s->pixel_size + j) ^ 0xff);
318 bytestream_put_byte(buf, -1);
326 int end_line =
s->avctx->height;
330 unsigned line_size =
s->logical_width *
s->pixel_size;
331 for (start_line = 0; start_line <
s->avctx->height; start_line++)
333 s->previous_frame->data[0] + start_line *
s->previous_frame->linesize[0],
337 for (end_line=
s->avctx->height; end_line > start_line; end_line--)
339 s->previous_frame->data[0] + (end_line - 1) *
s->previous_frame->linesize[0],
344 bytestream_put_be32(&buf, 0);
346 if ((start_line == 0 && end_line ==
s->avctx->height) || start_line ==
s->avctx->height)
347 bytestream_put_be16(&buf, 0);
349 bytestream_put_be16(&buf, 8);
350 bytestream_put_be16(&buf, start_line);
351 bytestream_put_be16(&buf, 0);
352 bytestream_put_be16(&buf, end_line - start_line);
353 bytestream_put_be16(&buf, 0);
355 for (
i = start_line;
i < end_line;
i++)
358 bytestream_put_byte(&buf, 0);
359 AV_WB32(orig_buf, buf - orig_buf);
360 return buf - orig_buf;
364 const AVFrame *pict,
int *got_packet)
390 #if FF_API_CODED_FRAME
#define FF_ENABLE_DEPRECATION_WARNINGS
AVPixelFormat
Pixel format.
static av_cold int init(AVCodecContext *avctx)
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
#define MAX_RLE_BULK
Maximum RLE code for bulk copy.
int * length_table
This array will contain the length of the best rle encoding of the line starting at ith pixel.
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
This structure describes decoded (raw) audio or video data.
static av_cold int qtrle_encode_end(AVCodecContext *avctx)
void * av_mallocz_array(size_t nmemb, size_t size)
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
@ AV_PIX_FMT_RGB555BE
packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), big-endian , X=unused/undefined
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
int key_frame
1 -> keyframe, 0-> not
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
static void qtrle_encode_line(QtrleEncContext *s, const AVFrame *p, int line, uint8_t **buf)
Compute the best RLE sequence for a line.
static enum AVPixelFormat pix_fmts[]
#define MAX_RLE_SKIP
Maximum RLE code for skip.
int key_frame
Encoded frame is a key frame.
uint8_t * skip_table
Will contain at ith position the number of consecutive pixels equal to the previous frame starting fr...
@ AV_PICTURE_TYPE_I
Intra.
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
#define MAX_RLE_REPEAT
Maximum RLE code for repeat.
enum AVPictureType pict_type
Picture type of the frame.
@ AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
static int encode_frame(QtrleEncContext *s, const AVFrame *p, uint8_t *buf)
Encode frame including header.
signed char * rlecode_table
This array will contain at ith position the value of the best RLE code if the line started at pixel i...
int flags
A combination of AV_PKT_FLAG values.
unsigned int max_buf_size
@ AV_PIX_FMT_ARGB
packed ARGB 8:8:8:8, 32bpp, ARGBARGB...
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
static av_always_inline void bytestream_put_buffer(uint8_t **b, const uint8_t *src, unsigned int size)
#define i(width, name, range_min, range_max)
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
const char * name
Name of the codec implementation.
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
attribute_deprecated AVFrame * coded_frame
the picture in the bitstream
main external API structure.
static int qtrle_encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pict, int *got_packet)
#define FF_DISABLE_DEPRECATION_WARNINGS
@ AV_PICTURE_TYPE_P
Predicted.
static av_cold int qtrle_encode_init(AVCodecContext *avctx)
This structure stores compressed data.
int width
picture width / height.
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
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...
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int64_t min_size)
Check AVPacket size and/or allocate data.