blob: a14dd2aab24594eee0ff7a33e5a3a40dbae798c1
1 | /* |
2 | * FFV1 codec for libavcodec |
3 | * |
4 | * Copyright (c) 2003-2013 Michael Niedermayer <michaelni@gmx.at> |
5 | * |
6 | * This file is part of FFmpeg. |
7 | * |
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. |
12 | * |
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. |
17 | * |
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 |
21 | */ |
22 | |
23 | /** |
24 | * @file |
25 | * FF Video Codec 1 (a lossless codec) |
26 | */ |
27 | |
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" |
35 | |
36 | #include "avcodec.h" |
37 | #include "internal.h" |
38 | #include "rangecoder.h" |
39 | #include "mathops.h" |
40 | #include "ffv1.h" |
41 | |
42 | av_cold int ff_ffv1_common_init(AVCodecContext *avctx) |
43 | { |
44 | FFV1Context *s = avctx->priv_data; |
45 | |
46 | if (!avctx->width || !avctx->height) |
47 | return AVERROR_INVALIDDATA; |
48 | |
49 | s->avctx = avctx; |
50 | s->flags = avctx->flags; |
51 | |
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); |
56 | |
57 | s->width = avctx->width; |
58 | s->height = avctx->height; |
59 | |
60 | // defaults |
61 | s->num_h_slices = 1; |
62 | s->num_v_slices = 1; |
63 | |
64 | return 0; |
65 | } |
66 | |
67 | av_cold int ff_ffv1_init_slice_state(FFV1Context *f, FFV1Context *fs) |
68 | { |
69 | int j, i; |
70 | |
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]; |
75 | |
76 | if (fs->ac != AC_GOLOMB_RICE) { |
77 | if (!p->state) |
78 | p->state = av_malloc_array(p->context_count, CONTEXT_SIZE * |
79 | sizeof(uint8_t)); |
80 | if (!p->state) |
81 | return AVERROR(ENOMEM); |
82 | } else { |
83 | if (!p->vlc_state) { |
84 | p->vlc_state = av_mallocz_array(p->context_count, sizeof(VlcState)); |
85 | if (!p->vlc_state) |
86 | return AVERROR(ENOMEM); |
87 | for (i = 0; i < p->context_count; i++) { |
88 | p->vlc_state[i].error_sum = 4; |
89 | p->vlc_state[i].count = 1; |
90 | } |
91 | } |
92 | } |
93 | } |
94 | |
95 | if (fs->ac == AC_RANGE_CUSTOM_TAB) { |
96 | //FIXME only redo if state_transition changed |
97 | for (j = 1; j < 256; j++) { |
98 | fs->c. one_state[ j] = f->state_transition[j]; |
99 | fs->c.zero_state[256 - j] = 256 - fs->c.one_state[j]; |
100 | } |
101 | } |
102 | |
103 | return 0; |
104 | } |
105 | |
106 | av_cold int ff_ffv1_init_slices_state(FFV1Context *f) |
107 | { |
108 | int i, ret; |
109 | for (i = 0; i < f->max_slice_count; i++) { |
110 | FFV1Context *fs = f->slice_context[i]; |
111 | if ((ret = ff_ffv1_init_slice_state(f, fs)) < 0) |
112 | return AVERROR(ENOMEM); |
113 | } |
114 | return 0; |
115 | } |
116 | |
117 | av_cold int ff_ffv1_init_slice_contexts(FFV1Context *f) |
118 | { |
119 | int i; |
120 | |
121 | f->max_slice_count = f->num_h_slices * f->num_v_slices; |
122 | av_assert0(f->max_slice_count > 0); |
123 | |
124 | for (i = 0; i < f->max_slice_count; i++) { |
125 | int sx = i % f->num_h_slices; |
126 | int sy = i / f->num_h_slices; |
127 | int sxs = f->avctx->width * sx / f->num_h_slices; |
128 | int sxe = f->avctx->width * (sx + 1) / f->num_h_slices; |
129 | int sys = f->avctx->height * sy / f->num_v_slices; |
130 | int sye = f->avctx->height * (sy + 1) / f->num_v_slices; |
131 | FFV1Context *fs = av_mallocz(sizeof(*fs)); |
132 | |
133 | if (!fs) |
134 | goto memfail; |
135 | |
136 | f->slice_context[i] = fs; |
137 | memcpy(fs, f, sizeof(*fs)); |
138 | memset(fs->rc_stat2, 0, sizeof(fs->rc_stat2)); |
139 | |
140 | fs->slice_width = sxe - sxs; |
141 | fs->slice_height = sye - sys; |
142 | fs->slice_x = sxs; |
143 | fs->slice_y = sys; |
144 | |
145 | fs->sample_buffer = av_malloc_array((fs->width + 6), 3 * MAX_PLANES * |
146 | sizeof(*fs->sample_buffer)); |
147 | fs->sample_buffer32 = av_malloc_array((fs->width + 6), 3 * MAX_PLANES * |
148 | sizeof(*fs->sample_buffer32)); |
149 | if (!fs->sample_buffer || !fs->sample_buffer32) { |
150 | av_freep(&fs->sample_buffer); |
151 | av_freep(&fs->sample_buffer32); |
152 | av_freep(&f->slice_context[i]); |
153 | goto memfail; |
154 | } |
155 | } |
156 | return 0; |
157 | |
158 | memfail: |
159 | while(--i >= 0) { |
160 | av_freep(&f->slice_context[i]->sample_buffer); |
161 | av_freep(&f->slice_context[i]->sample_buffer32); |
162 | av_freep(&f->slice_context[i]); |
163 | } |
164 | return AVERROR(ENOMEM); |
165 | } |
166 | |
167 | int ff_ffv1_allocate_initial_states(FFV1Context *f) |
168 | { |
169 | int i; |
170 | |
171 | for (i = 0; i < f->quant_table_count; i++) { |
172 | f->initial_states[i] = av_malloc_array(f->context_count[i], |
173 | sizeof(*f->initial_states[i])); |
174 | if (!f->initial_states[i]) |
175 | return AVERROR(ENOMEM); |
176 | memset(f->initial_states[i], 128, |
177 | f->context_count[i] * sizeof(*f->initial_states[i])); |
178 | } |
179 | return 0; |
180 | } |
181 | |
182 | void ff_ffv1_clear_slice_state(FFV1Context *f, FFV1Context *fs) |
183 | { |
184 | int i, j; |
185 | |
186 | for (i = 0; i < f->plane_count; i++) { |
187 | PlaneContext *p = &fs->plane[i]; |
188 | |
189 | p->interlace_bit_state[0] = 128; |
190 | p->interlace_bit_state[1] = 128; |
191 | |
192 | if (fs->ac != AC_GOLOMB_RICE) { |
193 | if (f->initial_states[p->quant_table_index]) { |
194 | memcpy(p->state, f->initial_states[p->quant_table_index], |
195 | CONTEXT_SIZE * p->context_count); |
196 | } else |
197 | memset(p->state, 128, CONTEXT_SIZE * p->context_count); |
198 | } else { |
199 | for (j = 0; j < p->context_count; j++) { |
200 | p->vlc_state[j].drift = 0; |
201 | p->vlc_state[j].error_sum = 4; //FFMAX((RANGE + 32)/64, 2); |
202 | p->vlc_state[j].bias = 0; |
203 | p->vlc_state[j].count = 1; |
204 | } |
205 | } |
206 | } |
207 | } |
208 | |
209 | |
210 | av_cold int ff_ffv1_close(AVCodecContext *avctx) |
211 | { |
212 | FFV1Context *s = avctx->priv_data; |
213 | int i, j; |
214 | |
215 | if (s->picture.f) |
216 | ff_thread_release_buffer(avctx, &s->picture); |
217 | av_frame_free(&s->picture.f); |
218 | |
219 | if (s->last_picture.f) |
220 | ff_thread_release_buffer(avctx, &s->last_picture); |
221 | av_frame_free(&s->last_picture.f); |
222 | |
223 | for (j = 0; j < s->max_slice_count; j++) { |
224 | FFV1Context *fs = s->slice_context[j]; |
225 | for (i = 0; i < s->plane_count; i++) { |
226 | PlaneContext *p = &fs->plane[i]; |
227 | |
228 | av_freep(&p->state); |
229 | av_freep(&p->vlc_state); |
230 | } |
231 | av_freep(&fs->sample_buffer); |
232 | av_freep(&fs->sample_buffer32); |
233 | } |
234 | |
235 | av_freep(&avctx->stats_out); |
236 | for (j = 0; j < s->quant_table_count; j++) { |
237 | av_freep(&s->initial_states[j]); |
238 | for (i = 0; i < s->max_slice_count; i++) { |
239 | FFV1Context *sf = s->slice_context[i]; |
240 | av_freep(&sf->rc_stat2[j]); |
241 | } |
242 | av_freep(&s->rc_stat2[j]); |
243 | } |
244 | |
245 | for (i = 0; i < s->max_slice_count; i++) |
246 | av_freep(&s->slice_context[i]); |
247 | |
248 | return 0; |
249 | } |
250 |