50 #define CVID_HEADER_SIZE 10
51 #define STRIP_HEADER_SIZE 12
52 #define CHUNK_HEADER_SIZE 4
55 #define MB_AREA (MB_SIZE * MB_SIZE)
58 #define CODEBOOK_MAX 256
131 #define OFFSET(x) offsetof(CinepakEncContext, x)
132 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
134 {
"max_extra_cb_iterations",
"Max extra codebook recalculation passes, more is better and slower",
136 {
"skip_empty_cb",
"Avoid wasting bytes, ignore vintage MacOS decoder",
138 {
"max_strips",
"Limit strips/frame, vintage compatible is 1..3, otherwise the more the better",
140 {
"min_strips",
"Enforce min strips/frame, more is worse and faster, must be <= max_strips",
142 {
"strip_number_adaptivity",
"How fast the strip number adapts, more is slightly better, much slower",
157 int x, mb_count, strip_buf_size, frame_buf_size;
160 av_log(avctx,
AV_LOG_ERROR,
"width and height must be multiples of four (got %ix%i)\n",
165 if (
s->min_min_strips >
s->max_max_strips) {
166 av_log(avctx,
AV_LOG_ERROR,
"minimum number of strips must not exceed maximum (got %i and %i)\n",
167 s->min_min_strips,
s->max_max_strips);
201 if (!(
s->strip_buf =
av_malloc(strip_buf_size)))
204 if (!(
s->frame_buf =
av_malloc(frame_buf_size)))
214 s->frame_buf_size = frame_buf_size;
220 s->last_frame->data[0] =
s->pict_bufs[0];
221 s->last_frame->linesize[0] =
s->w;
222 s->best_frame->data[0] =
s->pict_bufs[1];
223 s->best_frame->linesize[0] =
s->w;
224 s->scratch_frame->data[0] =
s->pict_bufs[2];
225 s->scratch_frame->linesize[0] =
s->w;
228 s->last_frame->data[1] =
s->last_frame->data[0] +
s->w *
s->h;
229 s->last_frame->data[2] =
s->last_frame->data[1] + ((
s->w *
s->h) >> 2);
230 s->last_frame->linesize[1] =
231 s->last_frame->linesize[2] =
s->w >> 1;
233 s->best_frame->data[1] =
s->best_frame->data[0] +
s->w *
s->h;
234 s->best_frame->data[2] =
s->best_frame->data[1] + ((
s->w *
s->h) >> 2);
235 s->best_frame->linesize[1] =
236 s->best_frame->linesize[2] =
s->w >> 1;
238 s->scratch_frame->data[1] =
s->scratch_frame->data[0] +
s->w *
s->h;
239 s->scratch_frame->data[2] =
s->scratch_frame->data[1] + ((
s->w *
s->h) >> 2);
240 s->scratch_frame->linesize[1] =
241 s->scratch_frame->linesize[2] =
s->w >> 1;
243 s->input_frame->data[0] =
s->pict_bufs[3];
244 s->input_frame->linesize[0] =
s->w;
245 s->input_frame->data[1] =
s->input_frame->data[0] +
s->w *
s->h;
246 s->input_frame->data[2] =
s->input_frame->data[1] + ((
s->w *
s->h) >> 2);
247 s->input_frame->linesize[1] =
248 s->input_frame->linesize[2] =
s->w >> 1;
251 s->min_strips =
s->min_min_strips;
252 s->max_strips =
s->max_max_strips;
259 int *training_set_v1_shrunk,
260 int *training_set_v4_shrunk)
267 int64_t score1, score2, score3;
272 switch (info->
mode) {
275 ret +=
s->lambda * 8 * mb_count;
278 for (x = 0; x < mb_count; x++) {
291 *training_set_v1_shrunk = *training_set_v4_shrunk = 0;
292 for (x = 0; x < mb_count; x++) {
302 for (x = 0; x < mb_count; x++) {
307 if (score1 <= score2) {
321 int v1_shrunk = 0, v4_shrunk = 0;
322 for (x = 0; x < mb_count; x++) {
329 }
else if (
mb->best_encoding ==
ENC_V1) {
347 *training_set_v1_shrunk = v1_shrunk;
348 *training_set_v4_shrunk = v4_shrunk;
350 for (x = 0; x < mb_count; x++) {
356 if (score1 <= score2 && score1 <= score3) {
359 }
else if (score2 <= score3) {
383 int chunk_type_yuv,
int chunk_type_gray,
387 int incremental_codebook_replacement_mode = 0;
392 chunk_type_yuv + (incremental_codebook_replacement_mode ? 1 : 0) :
393 chunk_type_gray + (incremental_codebook_replacement_mode ? 1 : 0),
395 (incremental_codebook_replacement_mode ? (
size + 31) / 32 * 4 : 0));
402 if (incremental_codebook_replacement_mode) {
405 for (x = 0; x <
size; x++) {
412 for (y = 0; y < entry_size; y++)
413 buf[ret++] =
codebook[y + x * entry_size] ^ (y >= 4 ? 0x80 : 0);
414 if ((
flags & 0xffffffff) == 0xffffffff) {
422 for (x = 0; x <
size; x++)
423 for (y = 0; y < entry_size; y++)
424 buf[ret++] =
codebook[y + x * entry_size] ^ (y >= 4 ? 0x80 : 0);
431 uint8_t * in_data[4],
int in_linesize[4],
432 uint8_t *out_data[4],
int out_linesize[4])
434 out_data[0] = in_data[0] + x + y * in_linesize[0];
435 out_linesize[0] = in_linesize[0];
438 out_data[1] = in_data[1] + (x >> 1) + (y >> 1) * in_linesize[1];
439 out_linesize[1] = in_linesize[1];
441 out_data[2] = in_data[2] + (x >> 1) + (y >> 1) * in_linesize[2];
442 out_linesize[2] = in_linesize[2];
448 int linesize[4],
int v1_vector,
strip_info *info)
454 data[0][ linesize[0]] =
459 data[0][2 + linesize[0]] =
460 data[0][3 + linesize[0]] = info->
v1_codebook[v1_vector * entry_size + 1];
462 data[0][ 2 * linesize[0]] =
463 data[0][1 + 2 * linesize[0]] =
464 data[0][ 3 * linesize[0]] =
465 data[0][1 + 3 * linesize[0]] = info->
v1_codebook[v1_vector * entry_size + 2];
467 data[0][2 + 2 * linesize[0]] =
468 data[0][3 + 2 * linesize[0]] =
469 data[0][2 + 3 * linesize[0]] =
470 data[0][3 + 3 * linesize[0]] = info->
v1_codebook[v1_vector * entry_size + 3];
475 data[1][ linesize[1]] =
476 data[1][1 + linesize[1]] = info->
v1_codebook[v1_vector * entry_size + 4];
480 data[2][ linesize[2]] =
481 data[2][1 + linesize[2]] = info->
v1_codebook[v1_vector * entry_size + 5];
487 int linesize[4],
int *v4_vector,
strip_info *info)
491 for (
i = y = 0; y < 4; y += 2) {
492 for (x = 0; x < 4; x += 2,
i++) {
493 data[0][x + y * linesize[0]] = info->
v4_codebook[v4_vector[
i] * entry_size];
494 data[0][x + 1 + y * linesize[0]] = info->
v4_codebook[v4_vector[
i] * entry_size + 1];
495 data[0][x + (y + 1) * linesize[0]] = info->
v4_codebook[v4_vector[
i] * entry_size + 2];
496 data[0][x + 1 + (y + 1) * linesize[0]] = info->
v4_codebook[v4_vector[
i] * entry_size + 3];
499 data[1][(x >> 1) + (y >> 1) * linesize[1]] = info->
v4_codebook[v4_vector[
i] * entry_size + 4];
500 data[2][(x >> 1) + (y >> 1) * linesize[2]] = info->
v4_codebook[v4_vector[
i] * entry_size + 5];
507 uint8_t *a_data[4],
int a_linesize[4],
508 uint8_t *b_data[4],
int b_linesize[4])
513 memcpy(a_data[0] + y * a_linesize[0], b_data[0] + y * b_linesize[0],
517 for (p = 1; p <= 2; p++)
518 for (y = 0; y <
MB_SIZE / 2; y++)
519 memcpy(a_data[p] + y * a_linesize[p],
520 b_data[p] + y * b_linesize[p],
526 uint8_t *scratch_data[4],
int scratch_linesize[4],
527 uint8_t *last_data[4],
int last_linesize[4],
530 int x, y, z,
bits, temp_size, header_ofs, ret = 0, mb_count =
s->w *
h /
MB_AREA;
531 int needs_extra_bit, should_write_temp;
533 unsigned char temp[64];
535 uint8_t *sub_scratch_data[4] = { 0 }, *sub_last_data[4] = { 0 };
536 int sub_scratch_linesize[4] = { 0 }, sub_last_linesize[4] = { 0 };
542 if (info->
v4_size || !
s->skip_empty_cb)
545 if (info->
v1_size || !
s->skip_empty_cb)
549 for (z = y = 0; y <
h; y +=
MB_SIZE)
550 for (x = 0; x <
s->w; x +=
MB_SIZE, z++) {
554 sub_scratch_data, sub_scratch_linesize);
558 sub_last_data, sub_last_linesize);
559 copy_mb(
s, sub_scratch_data, sub_scratch_linesize,
560 sub_last_data, sub_last_linesize);
563 mb->v1_vector, info);
566 mb->v4_vector, info);
569 switch (info->
mode) {
573 for (x = 0; x < mb_count; x++)
574 buf[ret++] =
s->mb[x].v1_vector;
582 for (x = 0; x < mb_count; x += 32) {
584 for (y = x; y <
FFMIN(x + 32, mb_count); y++)
585 if (
s->mb[y].best_encoding ==
ENC_V4)
586 flags |= 1U << (31 - y + x);
591 for (y = x; y <
FFMIN(x + 32, mb_count); y++) {
595 buf[ret++] =
mb->v1_vector;
597 for (z = 0; z < 4; z++)
598 buf[ret++] =
mb->v4_vector[z];
611 for (x = 0; x < mb_count; x++) {
615 should_write_temp = 0;
629 if (
mb->best_encoding ==
ENC_SKIP || needs_extra_bit) {
630 memcpy(&buf[ret],
temp, temp_size);
634 should_write_temp = 1;
637 if (needs_extra_bit) {
643 temp[temp_size++] =
mb->v1_vector;
644 else if (
mb->best_encoding ==
ENC_V4)
645 for (z = 0; z < 4; z++)
646 temp[temp_size++] =
mb->v4_vector[z];
648 if (should_write_temp) {
649 memcpy(&buf[ret],
temp, temp_size);
658 memcpy(&buf[ret],
temp, temp_size);
672 uint8_t *a_data[4],
int a_linesize[4],
673 uint8_t *b_data[4],
int b_linesize[4])
675 int x, y, p, d, ret = 0;
678 for (x = 0; x <
MB_SIZE; x++) {
679 d = a_data[0][x + y * a_linesize[0]] - b_data[0][x + y * b_linesize[0]];
684 for (p = 1; p <= 2; p++) {
685 for (y = 0; y <
MB_SIZE / 2; y++)
686 for (x = 0; x <
MB_SIZE / 2; x++) {
687 d = a_data[p][x + y * a_linesize[p]] - b_data[p][x + y * b_linesize[p]];
697 #define CERTAIN(x) ((x) != ENC_UNCERTAIN)
699 int linesize[4],
int v1mode,
strip_info *info,
702 int x, y,
i, j, k, x2, y2, x3, y3, plane,
shift, mbn;
708 uint8_t *sub_data[4], *vq_data[4];
709 int sub_linesize[4], vq_linesize[4];
711 for (mbn =
i = y = 0; y <
h; y +=
MB_SIZE) {
712 for (x = 0; x <
s->w; x +=
MB_SIZE, ++mbn) {
717 if (
s->mb[mbn].best_encoding != encoding)
721 base =
s->codebook_input +
i * entry_size;
724 for (j = y2 = 0; y2 < entry_size; y2 += 2)
725 for (x2 = 0; x2 < 4; x2 += 2, j++) {
726 plane = y2 < 4 ? 0 : 1 + (x2 >> 1);
727 shift = y2 < 4 ? 0 : 1;
731 data[plane][((x + x3) >>
shift) + 1 + ((y + y3) >>
shift) * linesize[plane]] +
732 data[plane][((x + x3) >>
shift) + (((y + y3) >>
shift) + 1) * linesize[plane]] +
733 data[plane][((x + x3) >>
shift) + 1 + (((y + y3) >>
shift) + 1) * linesize[plane]]) >> 2;
737 for (j = y2 = 0; y2 <
MB_SIZE; y2 += 2) {
738 for (x2 = 0; x2 <
MB_SIZE; x2 += 2)
739 for (k = 0; k < entry_size; k++, j++) {
740 plane = k >= 4 ? k - 3 : 0;
746 x3 = x + x2 + (k & 1);
747 y3 = y + y2 + (k >> 1);
750 base[j] =
data[plane][x3 + y3 * linesize[plane]];
767 vq_data[0] = vq_pict_buf;
769 vq_data[1] = &vq_pict_buf[
MB_AREA];
770 vq_data[2] = vq_data[1] + (
MB_AREA >> 2);
776 for (x = 0; x <
s->w; x +=
MB_SIZE, j++) {
779 if (
CERTAIN(encoding) &&
mb->best_encoding != encoding)
786 mb->v1_vector =
s->codebook_closest[
i];
792 vq_data, vq_linesize);
793 total_error +=
mb->v1_error;
795 for (k = 0; k < 4; k++)
796 mb->v4_vector[k] =
s->codebook_closest[
i + k];
802 vq_data, vq_linesize);
803 total_error +=
mb->v4_error;
814 uint8_t *last_data[4],
int last_linesize[4],
819 uint8_t *sub_last_data [4], *sub_pict_data [4];
820 int sub_last_linesize[4], sub_pict_linesize[4];
823 for (x = 0; x <
s->w; x +=
MB_SIZE,
i++) {
825 sub_last_data, sub_last_linesize);
827 sub_pict_data, sub_pict_linesize);
829 s->mb[
i].skip_error =
831 sub_last_data, sub_last_linesize,
832 sub_pict_data, sub_pict_linesize);
837 unsigned char *buf,
int strip_size)
844 buf[0] = keyframe ? 0x10 : 0x11;
855 uint8_t *last_data[4],
int last_linesize[4],
857 uint8_t *scratch_data[4],
int scratch_linesize[4],
858 unsigned char *buf,
int64_t *best_score)
864 int v1enough, v1_size, v4enough, v4_size;
865 int new_v1_size, new_v4_size;
866 int v1shrunk, v4shrunk;
876 #define SMALLEST_CODEBOOK 1
878 for (v4enough = 0, v4_size = 0; v4_size <= v1_size && !v4enough; v4_size = v4_size ? v4_size << 2 : v1_size >= SMALLEST_CODEBOOK << 2 ? v1_size >> 2 :
SMALLEST_CODEBOOK) {
914 &v1shrunk, &v4shrunk);
917 int extra_iterations_limit =
s->max_extra_cb_iterations;
922 if (new_v1_size < info.
v1_size)
927 if (new_v4_size < info.
v4_size)
935 &v1shrunk, &v4shrunk);
937 if ((!v1shrunk && !v4shrunk) || !extra_iterations_limit--)
943 if (new_v1_size < info.
v1_size)
949 if (new_v4_size < info.
v4_size)
955 if (best_size == 0 || score < *best_score) {
958 scratch_data, scratch_linesize,
959 last_data, last_linesize, &info,
969 memcpy(buf,
s->strip_buf, best_size);
975 int num_strips,
int data_size,
int isakeyframe)
977 buf[0] = isakeyframe ? 0 : 1;
987 int isakeyframe,
unsigned char *buf,
int buf_size)
989 int num_strips, strip,
i, y, nexty,
size, temp_size, best_size;
990 uint8_t *last_data [4], *
data [4], *scratch_data [4];
991 int last_linesize[4], linesize[4], scratch_linesize[4];
992 int64_t best_score = 0, score, score_temp;
998 for (y = 0; y <
s->h; y += 2)
999 for (x = 0; x <
s->w; x += 2) {
1005 s->input_frame->data,
s->input_frame->linesize,
1006 scratch_data, scratch_linesize);
1008 for (
i = 0;
i < 4; ++
i) {
1012 rr = ir[i2][i1 * 3 + 0];
1013 gg = ir[i2][i1 * 3 + 1];
1014 bb = ir[i2][i1 * 3 + 2];
1021 rr = (2396625 * rr + 4793251 * gg + 1198732 * bb) >> 23;
1026 scratch_data[0][i1 + i2 * scratch_linesize[0]] = rr;
1032 rr = (-299683 *
r - 599156 *
g + 898839 *
b) >> 23;
1037 scratch_data[1][0] = rr + 128;
1040 rr = (748893 *
r - 599156 *
g - 149737 *
b) >> 23;
1045 scratch_data[2][0] = rr + 128;
1051 for (num_strips =
s->min_strips; num_strips <= s->max_strips && num_strips <= s->
h /
MB_SIZE; num_strips++) {
1055 for (y = 0, strip = 1; y <
s->h; strip++, y = nexty) {
1058 nexty = strip *
s->h / num_strips;
1061 nexty += 4 - (nexty & 3);
1063 strip_height = nexty - y;
1064 if (strip_height <= 0) {
1065 av_log(
s->avctx,
AV_LOG_INFO,
"skipping zero height strip %i of %i\n", strip, num_strips);
1071 s->input_frame->data,
s->input_frame->linesize,
1078 s->last_frame->data,
s->last_frame->linesize,
1079 last_data, last_linesize);
1081 s->scratch_frame->data,
s->scratch_frame->linesize,
1082 scratch_data, scratch_linesize);
1084 if ((temp_size =
rd_strip(
s, y, strip_height, isakeyframe,
1085 last_data, last_linesize,
data, linesize,
1086 scratch_data, scratch_linesize,
1091 score += score_temp;
1095 if (best_score == 0 || score < best_score) {
1100 memcpy(buf,
s->frame_buf, best_size);
1101 best_nstrips = num_strips;
1105 if (num_strips - best_nstrips > 4)
1112 if (!
s->strip_number_delta_range) {
1113 if (best_nstrips ==
s->max_strips) {
1114 s->max_strips = best_nstrips + 1;
1115 if (
s->max_strips >=
s->max_max_strips)
1116 s->max_strips =
s->max_max_strips;
1118 s->max_strips = best_nstrips;
1120 s->min_strips =
s->max_strips - 1;
1121 if (
s->min_strips <
s->min_min_strips)
1122 s->min_strips =
s->min_min_strips;
1124 s->max_strips = best_nstrips +
s->strip_number_delta_range;
1125 if (
s->max_strips >=
s->max_max_strips)
1126 s->max_strips =
s->max_max_strips;
1127 s->min_strips = best_nstrips -
s->strip_number_delta_range;
1128 if (
s->min_strips <
s->min_min_strips)
1129 s->min_strips =
s->min_min_strips;
1147 if (
s->curframe == 0)
1153 if (++
s->curframe >=
s->keyint)
simple assert() macros that are a bit more flexible than ISO C assert().
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Libavcodec external API header.
static av_cold int init(AVCodecContext *avctx)
#define flags(name, subs,...)
static const unsigned codebook[256][2]
static void decode_v1_vector(CinepakEncContext *s, uint8_t *data[4], int linesize[4], int v1_vector, strip_info *info)
static int cinepak_encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *frame, int *got_packet)
#define STRIP_HEADER_SIZE
static int rd_strip(CinepakEncContext *s, int y, int h, int keyframe, uint8_t *last_data[4], int last_linesize[4], uint8_t *data[4], int linesize[4], uint8_t *scratch_data[4], int scratch_linesize[4], unsigned char *buf, int64_t *best_score)
static const AVOption options[]
static int rd_frame(CinepakEncContext *s, const AVFrame *frame, int isakeyframe, unsigned char *buf, int buf_size)
static void write_strip_header(CinepakEncContext *s, int y, int h, int keyframe, unsigned char *buf, int strip_size)
#define CHUNK_HEADER_SIZE
static int encode_mode(CinepakEncContext *s, int h, uint8_t *scratch_data[4], int scratch_linesize[4], uint8_t *last_data[4], int last_linesize[4], strip_info *info, unsigned char *buf)
static int compute_mb_distortion(CinepakEncContext *s, uint8_t *a_data[4], int a_linesize[4], uint8_t *b_data[4], int b_linesize[4])
#define SMALLEST_CODEBOOK
static void get_sub_picture(CinepakEncContext *s, int x, int y, uint8_t *in_data[4], int in_linesize[4], uint8_t *out_data[4], int out_linesize[4])
static int write_cvid_header(CinepakEncContext *s, unsigned char *buf, int num_strips, int data_size, int isakeyframe)
static int quantize(CinepakEncContext *s, int h, uint8_t *data[4], int linesize[4], int v1mode, strip_info *info, mb_encoding encoding)
static int64_t calculate_mode_score(CinepakEncContext *s, int h, strip_info *info, int report, int *training_set_v1_shrunk, int *training_set_v4_shrunk)
static void calculate_skip_errors(CinepakEncContext *s, int h, uint8_t *last_data[4], int last_linesize[4], uint8_t *data[4], int linesize[4], strip_info *info)
static void decode_v4_vector(CinepakEncContext *s, uint8_t *data[4], int linesize[4], int *v4_vector, strip_info *info)
AVCodec ff_cinepak_encoder
static int encode_codebook(CinepakEncContext *s, int *codebook, int size, int chunk_type_yuv, int chunk_type_gray, unsigned char *buf)
static void copy_mb(CinepakEncContext *s, uint8_t *a_data[4], int a_linesize[4], uint8_t *b_data[4], int b_linesize[4])
static int write_chunk_header(unsigned char *buf, int chunk_type, int chunk_size)
static const AVClass cinepak_class
static av_cold int cinepak_encode_init(AVCodecContext *avctx)
static av_cold int cinepak_encode_end(AVCodecContext *avctx)
common internal and external API header
#define FFSWAP(type, a, b)
mode
Use these values in ebur128_init (or'ed).
int avpriv_init_elbg(int *points, int dim, int numpoints, int *codebook, int numCB, int max_steps, int *closest_cb, AVLFG *rand_state)
Initialize the **codebook vector for the elbg algorithm.
int avpriv_do_elbg(int *points, int dim, int numpoints, int *codebook, int numCB, int max_steps, int *closest_cb, AVLFG *rand_state)
Implementation of the Enhanced LBG Algorithm Based on the paper "Neural Networks 14:1219-1237" that c...
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int64_t min_size)
Check AVPacket size and/or allocate data.
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
#define AV_LOG_INFO
Standard information.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
const char * av_default_item_name(void *ptr)
Return the context name.
#define LIBAVUTIL_VERSION_INT
av_cold void av_lfg_init(AVLFG *c, unsigned int seed)
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
common internal API header
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
static enum AVPixelFormat pix_fmts[]
AVPixelFormat
Pixel format.
@ AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
static int shift(int a, int b)
Describe the class of an AVClass context structure.
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
main external API structure.
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
int width
picture width / height.
int keyint_min
minimum GOP size
const char * name
Name of the codec implementation.
This structure describes decoded (raw) audio or video data.
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
int quality
quality (between 1 (good) and FF_LAMBDA_MAX (bad))
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Context structure for the Lagged Fibonacci PRNG.
This structure stores compressed data.
int flags
A combination of AV_PKT_FLAG values.
unsigned char * pict_bufs[4]
unsigned char * frame_buf
unsigned char * strip_buf
int strip_number_delta_range
enum AVPixelFormat pix_fmt
int max_extra_cb_iterations
mb_encoding best_encoding
int v4_codebook[CODEBOOK_MAX *VECTOR_MAX]
int v1_codebook[CODEBOOK_MAX *VECTOR_MAX]
#define av_malloc_array(a, b)