2 * FFV1 codec for libavcodec
4 * Copyright (c) 2003-2013 Michael Niedermayer <michaelni@gmx.at>
6 * This file is part of FFmpeg.
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.
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.
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
25 * FF Video Codec 1 (a lossless codec)
28 #include "libavutil/attributes.h"
29 #include "libavutil/avassert.h"
30 #include "libavutil/crc.h"
31 #include "libavutil/opt.h"
32 #include "libavutil/imgutils.h"
33 #include "libavutil/pixdesc.h"
34 #include "libavutil/timer.h"
37 #include "rangecoder.h"
42 av_cold
int ffv1_common_init(AVCodecContext
*avctx
)
44 FFV1Context
*s
= avctx
->priv_data
;
46 if (!avctx
->width
|| !avctx
->height
)
47 return AVERROR_INVALIDDATA
;
50 s
->flags
= avctx
->flags
;
52 s
->picture
.f
= av_frame_alloc();
53 s
->last_picture
.f
= av_frame_alloc();
54 if (!s
->picture
.f
|| !s
->last_picture
.f
)
55 return AVERROR(ENOMEM
);
57 s
->width
= avctx
->width
;
58 s
->height
= avctx
->height
;
67 av_cold
int ffv1_init_slice_state(FFV1Context
*f
, FFV1Context
*fs
)
71 fs
->plane_count
= f
->plane_count
;
72 fs
->transparency
= f
->transparency
;
73 for (j
= 0; j
< f
->plane_count
; j
++) {
74 PlaneContext
*const p
= &fs
->plane
[j
];
78 p
->state
= av_malloc_array(p
->context_count
, CONTEXT_SIZE
*
81 return AVERROR(ENOMEM
);
84 p
->vlc_state
= av_malloc_array(p
->context_count
, sizeof(VlcState
));
86 return AVERROR(ENOMEM
);
91 //FIXME only redo if state_transition changed
92 for (j
= 1; j
< 256; j
++) {
93 fs
->c
. one_state
[ j
] = f
->state_transition
[j
];
94 fs
->c
.zero_state
[256 - j
] = 256 - fs
->c
.one_state
[j
];
101 av_cold
int ffv1_init_slices_state(FFV1Context
*f
)
104 for (i
= 0; i
< f
->slice_count
; i
++) {
105 FFV1Context
*fs
= f
->slice_context
[i
];
106 if ((ret
= ffv1_init_slice_state(f
, fs
)) < 0)
107 return AVERROR(ENOMEM
);
112 av_cold
int ffv1_init_slice_contexts(FFV1Context
*f
)
116 f
->slice_count
= f
->num_h_slices
* f
->num_v_slices
;
117 av_assert0(f
->slice_count
> 0);
119 for (i
= 0; i
< f
->slice_count
; i
++) {
120 FFV1Context
*fs
= av_mallocz(sizeof(*fs
));
121 int sx
= i
% f
->num_h_slices
;
122 int sy
= i
/ f
->num_h_slices
;
123 int sxs
= f
->avctx
->width
* sx
/ f
->num_h_slices
;
124 int sxe
= f
->avctx
->width
* (sx
+ 1) / f
->num_h_slices
;
125 int sys
= f
->avctx
->height
* sy
/ f
->num_v_slices
;
126 int sye
= f
->avctx
->height
* (sy
+ 1) / f
->num_v_slices
;
129 return AVERROR(ENOMEM
);
131 f
->slice_context
[i
] = fs
;
132 memcpy(fs
, f
, sizeof(*fs
));
133 memset(fs
->rc_stat2
, 0, sizeof(fs
->rc_stat2
));
135 fs
->slice_width
= sxe
- sxs
;
136 fs
->slice_height
= sye
- sys
;
140 fs
->sample_buffer
= av_malloc_array((fs
->width
+ 6), 3 * MAX_PLANES
*
141 sizeof(*fs
->sample_buffer
));
142 if (!fs
->sample_buffer
)
143 return AVERROR(ENOMEM
);
148 int ffv1_allocate_initial_states(FFV1Context
*f
)
152 for (i
= 0; i
< f
->quant_table_count
; i
++) {
153 f
->initial_states
[i
] = av_malloc_array(f
->context_count
[i
],
154 sizeof(*f
->initial_states
[i
]));
155 if (!f
->initial_states
[i
])
156 return AVERROR(ENOMEM
);
157 memset(f
->initial_states
[i
], 128,
158 f
->context_count
[i
] * sizeof(*f
->initial_states
[i
]));
163 void ffv1_clear_slice_state(FFV1Context
*f
, FFV1Context
*fs
)
167 for (i
= 0; i
< f
->plane_count
; i
++) {
168 PlaneContext
*p
= &fs
->plane
[i
];
170 p
->interlace_bit_state
[0] = 128;
171 p
->interlace_bit_state
[1] = 128;
174 if (f
->initial_states
[p
->quant_table_index
]) {
175 memcpy(p
->state
, f
->initial_states
[p
->quant_table_index
],
176 CONTEXT_SIZE
* p
->context_count
);
178 memset(p
->state
, 128, CONTEXT_SIZE
* p
->context_count
);
180 for (j
= 0; j
< p
->context_count
; j
++) {
181 p
->vlc_state
[j
].drift
= 0;
182 p
->vlc_state
[j
].error_sum
= 4; //FFMAX((RANGE + 32)/64, 2);
183 p
->vlc_state
[j
].bias
= 0;
184 p
->vlc_state
[j
].count
= 1;
191 av_cold
int ffv1_close(AVCodecContext
*avctx
)
193 FFV1Context
*s
= avctx
->priv_data
;
197 ff_thread_release_buffer(avctx
, &s
->picture
);
198 av_frame_free(&s
->picture
.f
);
200 if (s
->last_picture
.f
)
201 ff_thread_release_buffer(avctx
, &s
->last_picture
);
202 av_frame_free(&s
->last_picture
.f
);
204 for (j
= 0; j
< s
->slice_count
; j
++) {
205 FFV1Context
*fs
= s
->slice_context
[j
];
206 for (i
= 0; i
< s
->plane_count
; i
++) {
207 PlaneContext
*p
= &fs
->plane
[i
];
210 av_freep(&p
->vlc_state
);
212 av_freep(&fs
->sample_buffer
);
215 av_freep(&avctx
->stats_out
);
216 for (j
= 0; j
< s
->quant_table_count
; j
++) {
217 av_freep(&s
->initial_states
[j
]);
218 for (i
= 0; i
< s
->slice_count
; i
++) {
219 FFV1Context
*sf
= s
->slice_context
[i
];
220 av_freep(&sf
->rc_stat2
[j
]);
222 av_freep(&s
->rc_stat2
[j
]);
225 for (i
= 0; i
< s
->slice_count
; i
++)
226 av_freep(&s
->slice_context
[i
]);