huffyuvenc.c File Reference

huffyuv encoder More...

#include "avcodec.h"
#include "huffyuv.h"
#include "huffman.h"
#include "huffyuvencdsp.h"
#include "internal.h"
#include "lossless_videoencdsp.h"
#include "put_bits.h"
#include "libavutil/opt.h"
#include "libavutil/pixdesc.h"

Macros
#define	STATS_OUT_SIZE   21*MAX_N*3 + 4
#define	LOAD4
#define	LOADEND   int y0 = s->temp[0][width-1];
#define	LOADEND_14   int y0 = s->temp16[0][width-1] & mask;
#define	LOADEND_16   int y0 = s->temp16[0][width-1];
#define	STATEND   s->stats[plane][y0]++;
#define	STATEND_16   s->stats[plane][y0>>2]++;
#define	WRITEEND   put_bits(&s->pb, s->len[plane][y0], s->bits[plane][y0]);
#define	WRITEEND_16
#define	LOAD2
#define	LOAD2_14
#define	LOAD2_16
#define	STAT2
#define	STAT2_16
#define	WRITE2
#define	WRITE2_16
#define	LOAD2
#define	STAT2
#define	WRITE2
#define	LOAD_GBRA
#define	STAT_BGRA
#define	WRITE_GBRA
#define	OFFSET(x)   offsetof(HYuvContext, x)
#define	VE   AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
#define	COMMON_OPTIONS

Variables
AVCodec	ff_huffyuv_encoder

Detailed Description

huffyuv encoder

Macro Definition Documentation

COMMON_OPTIONS

#define COMMON_OPTIONS

Value:

{ "non_deterministic", "Allow multithreading for e.g. context=1 at the expense of determinism", \
      OFFSET(non_determ), AV_OPT_TYPE_BOOL, { .i64 = 1 }, \
      0, 1, VE }, \
    { "pred", "Prediction method", OFFSET(predictor), AV_OPT_TYPE_INT, { .i64 = LEFT }, LEFT, MEDIAN, VE, "pred" }, \
        { "left",   NULL, 0, AV_OPT_TYPE_CONST, { .i64 = LEFT },   INT_MIN, INT_MAX, VE, "pred" }, \
        { "plane",  NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PLANE },  INT_MIN, INT_MAX, VE, "pred" }, \
        { "median", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = MEDIAN }, INT_MIN, INT_MAX, VE, "pred" }, \

LOAD2 [1/2]

#define LOAD2

Value:

int y0 = s->temp[0][2 * i];\
            int y1 = s->temp[0][2 * i + 1];

LOAD2 [2/2]

#define LOAD2

Value:

int y0 = s->temp[0][2 * i];\
            int y1 = s->temp[0][2 * i + 1];

LOAD2_14

#define LOAD2_14

Value:

int y0 = s->temp16[0][2 * i] & mask;\
            int y1 = s->temp16[0][2 * i + 1] & mask;

LOAD2_16

#define LOAD2_16

Value:

int y0 = s->temp16[0][2 * i];\
            int y1 = s->temp16[0][2 * i + 1];

LOAD4

#define LOAD4

Value:

int y0 = y[2 * i];\
            int y1 = y[2 * i + 1];\
            int u0 = u[i];\
            int v0 = v[i];

LOAD_GBRA

#define LOAD_GBRA

Value:

int g = s->temp[0][planes == 3 ? 3 * i + 1 : 4 * i + G];            \
    int b =(s->temp[0][planes == 3 ? 3 * i + 2 : 4 * i + B] - g) & 0xFF;\
    int r =(s->temp[0][planes == 3 ? 3 * i + 0 : 4 * i + R] - g) & 0xFF;\
    int a = s->temp[0][planes * i + A];

STAT2 [1/2]

#define STAT2

Value:

s->stats[plane][y0]++;\
            s->stats[plane][y1]++;

STAT2 [2/2]

#define STAT2

Value:

s->stats[0][y0]++;\
            s->stats[0][y1]++;

STAT2_16

#define STAT2_16

Value:

s->stats[plane][y0>>2]++;\
            s->stats[plane][y1>>2]++;

STAT_BGRA

#define STAT_BGRA

Value:

s->stats[0][b]++;                                                   \
    s->stats[1][g]++;                                                   \
    s->stats[2][r]++;                                                   \
    if (planes == 4)                                                    \
        s->stats[2][a]++;

WRITE2 [1/2]

#define WRITE2

Value:

put_bits(&s->pb, s->len[plane][y0], s->bits[plane][y0]);\
            put_bits(&s->pb, s->len[plane][y1], s->bits[plane][y1]);

WRITE2 [2/2]

#define WRITE2

Value:

put_bits(&s->pb, s->len[0][y0], s->bits[0][y0]);\
            put_bits(&s->pb, s->len[0][y1], s->bits[0][y1]);

WRITE2_16

#define WRITE2_16

Value:

put_bits(&s->pb, s->len[plane][y0>>2], s->bits[plane][y0>>2]);\
            put_bits(&s->pb, 2, y0&3);\
            put_bits(&s->pb, s->len[plane][y1>>2], s->bits[plane][y1>>2]);\
            put_bits(&s->pb, 2, y1&3);

WRITE_GBRA

#define WRITE_GBRA

Value:

put_bits(&s->pb, s->len[1][g], s->bits[1][g]);                      \
    put_bits(&s->pb, s->len[0][b], s->bits[0][b]);                      \
    put_bits(&s->pb, s->len[2][r], s->bits[2][r]);                      \
    if (planes == 4)                                                    \
        put_bits(&s->pb, s->len[2][a], s->bits[2][a]);

WRITEEND_16

#define WRITEEND_16

Value:

put_bits(&s->pb, s->len[plane][y0>>2], s->bits[plane][y0>>2]);\
            put_bits(&s->pb, 2, y0&3);

Variable Documentation

ff_huffyuv_encoder

AVCodec ff_huffyuv_encoder

Initial value:

= {
    .name           = "huffyuv",
    .long_name      = NULL_IF_CONFIG_SMALL("Huffyuv / HuffYUV"),
    .type           = AVMEDIA_TYPE_VIDEO,
    .id             = AV_CODEC_ID_HUFFYUV,
    .priv_data_size = sizeof(HYuvContext),
    .init           = encode_init,
    .encode2        = encode_frame,
    .close          = encode_end,
    .capabilities   = AV_CODEC_CAP_FRAME_THREADS | AV_CODEC_CAP_INTRA_ONLY,
    .priv_class     = &normal_class,
    .pix_fmts       = (const enum AVPixelFormat[]){
        AV_PIX_FMT_YUV422P, AV_PIX_FMT_RGB24,
        AV_PIX_FMT_RGB32, AV_PIX_FMT_NONE
    },
    .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE |
                      FF_CODEC_CAP_INIT_CLEANUP,
}