46 s->
llviddsp.
diff_int16((uint16_t *)dst, (
const uint16_t *)src0, (
const uint16_t *)src1, s->
n - 1, w);
56 for (i = 0; i < w; i++) {
57 const int temp = src[i];
63 for (i = 0; i < 16; i++) {
64 const int temp = src[i];
72 const uint16_t *src16 = (
const uint16_t *)src;
73 uint16_t *dst16 = ( uint16_t *)dst;
75 for (i = 0; i < w; i++) {
76 const int temp = src16[i];
77 dst16[i] = temp - left;
82 for (i = 0; i < 16; i++) {
83 const int temp = src16[i];
84 dst16[i] = temp - left;
95 int *red,
int *green,
int *blue,
105 for (i = 0; i <
FFMIN(w, 4); i++) {
106 const int rt = src[i * 4 +
R];
107 const int gt = src[i * 4 +
G];
108 const int bt = src[i * 4 +
B];
109 const int at = src[i * 4 +
A];
110 dst[i * 4 +
R] = rt -
r;
111 dst[i * 4 +
G] = gt -
g;
112 dst[i * 4 +
B] = bt -
b;
113 dst[i * 4 +
A] = at -
a;
122 *red = src[(w - 1) * 4 +
R];
123 *green = src[(w - 1) * 4 +
G];
124 *blue = src[(w - 1) * 4 +
B];
125 *alpha = src[(w - 1) * 4 +
A];
130 int *red,
int *green,
int *blue)
137 for (i = 0; i <
FFMIN(w, 16); i++) {
138 const int rt = src[i * 3 + 0];
139 const int gt = src[i * 3 + 1];
140 const int bt = src[i * 3 + 2];
141 dst[i * 3 + 0] = rt -
r;
142 dst[i * 3 + 1] = gt -
g;
143 dst[i * 3 + 2] = bt -
b;
151 *red = src[(w - 1) * 3 + 0];
152 *green = src[(w - 1) * 3 + 1];
153 *blue = src[(w - 1) * 3 + 2];
171 for (i = 0; i <
n;) {
175 for (; i < n && len[i] == val && repeat < 255; i++)
178 av_assert0(val < 32 && val >0 && repeat < 256 && repeat>0);
181 buf[index++] = repeat;
183 buf[index++] = val | (repeat << 5);
199 for (i = 0; i <
count; i++) {
226 #define STATS_OUT_SIZE 21*MAX_N*3 + 4
321 "context=1 is not compatible with "
322 "2 pass huffyuv encoding\n");
330 "Error: YV12 is not supported by huffyuv; use "
331 "vcodec=ffvhuff or format=422p\n");
336 "Error: per-frame huffman tables are not supported "
337 "by huffyuv; use vcodec=ffvhuff\n");
342 "Error: ver>2 is not supported "
343 "by huffyuv; use vcodec=ffvhuff\n");
348 "using huffyuv 2.2.0 or newer interlacing flag\n");
352 av_log(avctx,
AV_LOG_ERROR,
"Ver > 3 is under development, files encoded with it may not be decodable with future versions!!!\n"
353 "Use vstrict=-2 / -strict -2 to use it anyway.\n");
359 "Error: RGB is incompatible with median predictor\n");
383 for (i = 0; i < 4; i++)
384 for (j = 0; j < s->
vlc_n; j++)
388 for (i = 0; i < 4; i++) {
391 for (j = 0; j < s->
vlc_n; j++) {
392 s->
stats[i][j] += strtol(p, &next, 0);
393 if (next == p)
return -1;
397 if (p[0] == 0 || p[1] == 0 || p[2] == 0)
break;
400 for (i = 0; i < 4; i++)
401 for (j = 0; j < s->
vlc_n; j++) {
404 s->
stats[i][j] = 100000000 / (d*d + 1);
414 for (i = 0; i < 4; i++) {
416 for (j = 0; j < s->
vlc_n; j++) {
418 s->
stats[i][j] = pels/(d*d + 1);
422 for (i = 0; i < 4; i++)
423 for (j = 0; j < s->
vlc_n; j++)
450 int y1 = y[2 * i + 1];\
457 for(i = 0; i <
count; i++) {
468 for (i = 0; i <
count; i++) {
480 for(i = 0; i <
count; i++) {
493 int i,
count = width/2;
501 int y0 = s->temp[0][width-1];
503 int y0 = s->temp16[0][width-1] & mask;
505 int y0 = s->temp16[0][width-1];
507 s->stats[plane][y0]++;
509 s->stats[plane][y0>>2]++;
511 put_bits(&s->pb, s->len[plane][y0], s->bits[plane][y0]);
513 put_bits(&s->pb, s->len[plane][y0>>2], s->bits[plane][y0>>2]);\
514 put_bits(&s->pb, 2, y0&3);
517 int y0 = s->temp[0][2 * i];\
518 int y1 = s->temp[0][2 * i + 1];
520 int y0 = s->temp16[0][2 * i] & mask;\
521 int y1 = s->temp16[0][2 * i + 1] & mask;
523 int y0 = s->temp16[0][2 * i];\
524 int y1 = s->temp16[0][2 * i + 1];
526 s->stats[plane][y0]++;\
527 s->stats[plane][y1]++;
529 s->stats[plane][y0>>2]++;\
530 s->stats[plane][y1>>2]++;
532 put_bits(&s->pb, s->len[plane][y0], s->bits[plane][y0]);\
533 put_bits(&s->pb, s->len[plane][y1], s->bits[plane][y1]);
535 put_bits(&s->pb, s->len[plane][y0>>2], s->bits[plane][y0>>2]);\
536 put_bits(&s->pb, 2, y0&3);\
537 put_bits(&s->pb, s->len[plane][y1>>2], s->bits[plane][y1>>2]);\
538 put_bits(&s->pb, 2, y1&3);
542 for (i = 0; i <
count; i++) {
555 for (i = 0; i <
count; i++) {
566 for (i = 0; i <
count; i++) {
575 }
else if (s->
bps <= 14) {
578 for (i = 0; i <
count; i++) {
591 for (i = 0; i <
count; i++) {
602 for (i = 0; i <
count; i++) {
613 for (i = 0; i <
count; i++) {
626 for (i = 0; i <
count; i++) {
637 for (i = 0; i <
count; i++) {
663 int y0 = s->temp[0][2 * i];\
664 int y1 = s->temp[0][2 * i + 1];
669 put_bits(&s->pb, s->len[0][y0], s->bits[0][y0]);\
670 put_bits(&s->pb, s->len[0][y1], s->bits[0][y1]);
675 for (i = 0; i <
count; i++) {
684 for (i = 0; i <
count; i++) {
690 for (i = 0; i <
count; i++) {
703 4 * planes * count) {
709 int g = s->temp[0][planes == 3 ? 3 * i + 1 : 4 * i + G]; \
710 int b =(s->temp[0][planes == 3 ? 3 * i + 2 : 4 * i + B] - g) & 0xFF;\
711 int r =(s->temp[0][planes == 3 ? 3 * i + 0 : 4 * i + R] - g) & 0xFF;\
712 int a = s->temp[0][planes * i + A];
722 put_bits(&s->pb, s->len[1][g], s->bits[1][g]); \
723 put_bits(&s->pb, s->len[0][b], s->bits[0][b]); \
724 put_bits(&s->pb, s->len[2][r], s->bits[2][r]); \
726 put_bits(&s->pb, s->len[2][a], s->bits[2][a]);
730 for (i = 0; i <
count; i++) {
735 for (i = 0; i <
count; i++) {
741 for (i = 0; i <
count; i++) {
750 const AVFrame *pict,
int *got_packet)
754 const int width2 = s->
width>>1;
759 const AVFrame *
const p = pict;
770 for (i = 0; i < 4; i++)
771 for (j = 0; j < s->
vlc_n; j++)
772 s->
stats[i][j] >>= 1;
779 int lefty, leftu, leftv,
y, cy;
793 int lefttopy, lefttopu, lefttopv;
810 lefttopy = p->
data[0][3];
811 lefttopu = p->
data[1][1];
812 lefttopv = p->
data[2][1];
819 for (; y <
height; y++,cy++) {
829 if (y >= height)
break;
842 for (cy = y = 1; y <
height; y++, cy++) {
858 if (y >= height)
break;
885 const int fake_stride = -fake_ystride;
887 int leftr, leftg, leftb, lefta;
895 &leftr, &leftg, &leftb, &lefta);
903 &leftr, &leftg, &leftb, &lefta);
906 &leftr, &leftg, &leftb, &lefta);
913 const int fake_stride = -fake_ystride;
915 int leftr, leftg, leftb;
923 &leftr, &leftg, &leftb);
932 &leftr, &leftg, &leftb);
935 &leftr, &leftg, &leftb);
941 for (plane = 0; plane < 1 + 2*s->
chroma + s->
alpha; plane++) {
945 int fake_stride = fake_ystride;
947 if (s->
chroma && (plane == 1 || plane == 2)) {
950 fake_stride = plane == 1 ? fake_ustride : fake_vstride;
967 lefttop = p->
data[plane][0];
977 for (y = 1; y < h; y++) {
1006 for (i = 0; i < 4; i++) {
1007 for (j = 0; j < s->
vlc_n; j++) {
1026 pkt->
size = size * 4;
1048 {
"non_deterministic",
"Allow multithreading for e.g. context=1 at the expense of determinism",
1078 .priv_class = &normal_class,
1085 #if CONFIG_FFVHUFF_ENCODER
1086 AVCodec ff_ffvhuff_encoder = {
1096 .priv_class = &ff_class,
void(* bswap_buf)(uint32_t *dst, const uint32_t *src, int w)
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size)
Check AVPacket size and/or allocate data.
const struct AVCodec * codec
const char const char void * val
#define AV_PIX_FMT_YUVA422P16
#define AV_PIX_FMT_YUVA422P9
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
This structure describes decoded (raw) audio or video data.
static av_cold int encode_init(AVCodecContext *avctx)
ptrdiff_t const GLvoid * data
#define AV_PIX_FMT_YUVA420P10
#define AV_PIX_FMT_YUV444P14
#define CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
#define AV_PIX_FMT_YUVA422P10
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
#define LIBAVUTIL_VERSION_INT
packed RGB 8:8:8, 24bpp, RGBRGB...
#define CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
AVFrame * coded_frame
the picture in the bitstream
static av_cold int init(AVCodecContext *avctx)
#define AV_PIX_FMT_GBRP10
static int encode_plane_bitstream(HYuvContext *s, int width, int plane)
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
#define AV_PIX_FMT_YUV420P12
char * stats_in
pass2 encoding statistics input buffer Concatenated stuff from stats_out of pass1 should be placed he...
void(* sub_hfyu_median_pred)(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int w, int *left, int *left_top)
Subtract HuffYUV's variant of median prediction.
av_cold void ff_huffyuvencdsp_init(HuffYUVEncDSPContext *c)
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
int context_model
context model
#define av_assert0(cond)
assert() equivalent, that is always enabled.
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
#define AV_PIX_FMT_FLAG_ALPHA
The pixel format has an alpha channel.
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
#define CODEC_CAP_INTRA_ONLY
Codec is intra only.
static av_cold int end(AVCodecContext *avctx)
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
void(* diff_int16)(uint16_t *dst, const uint16_t *src1, const uint16_t *src2, unsigned mask, int w)
#define AV_PIX_FMT_YUVA420P9
static void sub_median_prediction(HYuvContext *s, uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int w, int *left, int *left_top)
#define AV_PIX_FMT_YUV444P16
static void sub_left_prediction_rgb24(HYuvContext *s, uint8_t *dst, uint8_t *src, int w, int *red, int *green, int *blue)
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
#define AV_PIX_FMT_YUV422P12
char * stats_out
pass1 encoding statistics output buffer
#define AV_PIX_FMT_YUVA420P16
#define AV_OPT_FLAG_ENCODING_PARAM
a generic parameter which can be set by the user for muxing or encoding
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
uint8_t len[4][MAX_VLC_N]
static int encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pict, int *got_packet)
av_cold int ff_huffyuv_alloc_temp(HYuvContext *s)
planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples)
uint16_t depth_minus1
Number of bits in the component minus 1.
static double alpha(void *priv, double x, double y)
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
av_cold void ff_huffyuv_common_end(HYuvContext *s)
#define CODEC_FLAG_INTERLACED_ME
interlaced motion estimation
static const uint16_t mask[17]
#define AV_PIX_FMT_FLAG_RGB
The pixel format contains RGB-like data (as opposed to YUV/grayscale).
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
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.
void(* diff_bytes)(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int w)
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
static const AVClass ff_class
#define AV_PIX_FMT_YUVA444P16
const char * name
Name of the codec implementation.
#define AV_PIX_FMT_YUV444P10
static const AVClass normal_class
static const uint8_t offset[127][2]
Libavcodec external API header.
huffyuv codec for libavcodec.
int flags
A combination of AV_PKT_FLAG values.
static int put_bits_count(PutBitContext *s)
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
#define AV_PIX_FMT_YUV422P9
#define FF_COMPLIANCE_EXPERIMENTAL
Allow nonstandardized experimental things.
uint8_t nb_components
The number of components each pixel has, (1-4)
enum AVPictureType pict_type
Picture type of the frame.
#define AV_PIX_FMT_GBRP16
#define AV_PIX_FMT_GRAY16
AVCodec ff_huffyuv_encoder
#define FF_MIN_BUFFER_SIZE
minimum encoding buffer size Used to avoid some checks during header writing.
int ff_huffyuv_generate_bits_table(uint32_t *dst, const uint8_t *len_table, int n)
#define AV_PIX_FMT_YUVA444P10
static av_cold int encode_end(AVCodecContext *avctx)
#define AV_PIX_FMT_YUV444P9
#define AV_PIX_FMT_GBRP14
#define AV_PIX_FMT_YUV420P16
#define AV_LOG_INFO
Standard information.
#define AV_PIX_FMT_YUV420P14
int ff_huff_gen_len_table(uint8_t *dst, const uint64_t *stats, int stats_size, int skip0)
static int sub_left_prediction(HYuvContext *s, uint8_t *dst, const uint8_t *src, int w, int left)
static int encode_422_bitstream(HYuvContext *s, int offset, int count)
static const AVOption options[]
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
#define AV_OPT_FLAG_VIDEO_PARAM
main external API structure.
BYTE int const BYTE int int int height
#define AV_PIX_FMT_YUV420P10
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
Describe the class of an AVClass context structure.
huffman tree builder and VLC generator
static int encode_bgra_bitstream(HYuvContext *s, int count, int planes)
#define AV_PIX_FMT_YUV420P9
#define AV_PIX_FMT_YUV422P14
#define AV_PIX_FMT_GBRP12
HuffYUVEncDSPContext hencdsp
#define AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV444P12
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
static void diff_bytes(HYuvContext *s, uint8_t *dst, const uint8_t *src0, const uint8_t *src1, int w)
GLint GLenum GLboolean GLsizei stride
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
common internal api header.
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
static int store_huffman_tables(HYuvContext *s, uint8_t *buf)
#define CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
#define CODEC_FLAG2_NO_OUTPUT
Skip bitstream encoding.
planar GBRA 4:4:4:4 32bpp
static int store_table(HYuvContext *s, const uint8_t *len, uint8_t *buf)
int prediction_method
prediction method (needed for huffyuv)
#define AV_PIX_FMT_YUVA444P9
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
static int encode_gray_bitstream(HYuvContext *s, int count)
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
static void sub_left_prediction_bgr32(HYuvContext *s, uint8_t *dst, const uint8_t *src, int w, int *red, int *green, int *blue, int *alpha)
av_cold void ff_huffyuv_common_init(AVCodecContext *avctx)
int key_frame
1 -> keyframe, 0-> not
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
uint32_t bits[4][MAX_VLC_N]
uint64_t stats[4][MAX_VLC_N]
void(* sub_hfyu_median_pred_int16)(uint16_t *dst, const uint16_t *src1, const uint16_t *src2, unsigned mask, int w, int *left, int *left_top)
AVPixelFormat
Pixel format.
This structure stores compressed data.
#define AV_PIX_FMT_FLAG_PLANAR
At least one pixel component is not in the first data plane.
void * av_mallocz(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
int strict_std_compliance
strictly follow the standard (MPEG4, ...).
#define AV_PIX_FMT_YUV422P16