Line data Source code
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 85 : av_cold int ff_ffv1_common_init(AVCodecContext *avctx)
43 : {
44 85 : FFV1Context *s = avctx->priv_data;
45 :
46 85 : if (!avctx->width || !avctx->height)
47 0 : return AVERROR_INVALIDDATA;
48 :
49 85 : s->avctx = avctx;
50 85 : s->flags = avctx->flags;
51 :
52 85 : s->picture.f = av_frame_alloc();
53 85 : s->last_picture.f = av_frame_alloc();
54 85 : if (!s->picture.f || !s->last_picture.f)
55 0 : return AVERROR(ENOMEM);
56 :
57 85 : s->width = avctx->width;
58 85 : s->height = avctx->height;
59 :
60 : // defaults
61 85 : s->num_h_slices = 1;
62 85 : s->num_v_slices = 1;
63 :
64 85 : return 0;
65 : }
66 :
67 10104 : av_cold int ff_ffv1_init_slice_state(FFV1Context *f, FFV1Context *fs)
68 : {
69 : int j, i;
70 :
71 10104 : fs->plane_count = f->plane_count;
72 10104 : fs->transparency = f->transparency;
73 30312 : for (j = 0; j < f->plane_count; j++) {
74 20208 : PlaneContext *const p = &fs->plane[j];
75 :
76 20208 : if (fs->ac != AC_GOLOMB_RICE) {
77 9888 : if (!p->state)
78 480 : p->state = av_malloc_array(p->context_count, CONTEXT_SIZE *
79 : sizeof(uint8_t));
80 9888 : if (!p->state)
81 0 : return AVERROR(ENOMEM);
82 : } else {
83 10320 : if (!p->vlc_state) {
84 520 : p->vlc_state = av_mallocz_array(p->context_count, sizeof(VlcState));
85 520 : if (!p->vlc_state)
86 0 : return AVERROR(ENOMEM);
87 213640 : for (i = 0; i < p->context_count; i++) {
88 213120 : p->vlc_state[i].error_sum = 4;
89 213120 : p->vlc_state[i].count = 1;
90 : }
91 : }
92 : }
93 : }
94 :
95 10104 : if (fs->ac == AC_RANGE_CUSTOM_TAB) {
96 : //FIXME only redo if state_transition changed
97 1265664 : for (j = 1; j < 256; j++) {
98 1260720 : fs->c. one_state[ j] = f->state_transition[j];
99 1260720 : fs->c.zero_state[256 - j] = 256 - fs->c.one_state[j];
100 : }
101 : }
102 :
103 10104 : return 0;
104 : }
105 :
106 28 : av_cold int ff_ffv1_init_slices_state(FFV1Context *f)
107 : {
108 : int i, ret;
109 128 : for (i = 0; i < f->max_slice_count; i++) {
110 100 : FFV1Context *fs = f->slice_context[i];
111 100 : if ((ret = ff_ffv1_init_slice_state(f, fs)) < 0)
112 0 : return AVERROR(ENOMEM);
113 : }
114 28 : return 0;
115 : }
116 :
117 85 : av_cold int ff_ffv1_init_slice_contexts(FFV1Context *f)
118 : {
119 : int i;
120 :
121 85 : f->max_slice_count = f->num_h_slices * f->num_v_slices;
122 85 : av_assert0(f->max_slice_count > 0);
123 :
124 389 : for (i = 0; i < f->max_slice_count; i++) {
125 304 : int sx = i % f->num_h_slices;
126 304 : int sy = i / f->num_h_slices;
127 304 : int sxs = f->avctx->width * sx / f->num_h_slices;
128 304 : int sxe = f->avctx->width * (sx + 1) / f->num_h_slices;
129 304 : int sys = f->avctx->height * sy / f->num_v_slices;
130 304 : int sye = f->avctx->height * (sy + 1) / f->num_v_slices;
131 304 : FFV1Context *fs = av_mallocz(sizeof(*fs));
132 :
133 304 : if (!fs)
134 0 : goto memfail;
135 :
136 304 : f->slice_context[i] = fs;
137 304 : memcpy(fs, f, sizeof(*fs));
138 304 : memset(fs->rc_stat2, 0, sizeof(fs->rc_stat2));
139 :
140 304 : fs->slice_width = sxe - sxs;
141 304 : fs->slice_height = sye - sys;
142 304 : fs->slice_x = sxs;
143 304 : fs->slice_y = sys;
144 :
145 304 : fs->sample_buffer = av_malloc_array((fs->width + 6), 3 * MAX_PLANES *
146 : sizeof(*fs->sample_buffer));
147 304 : fs->sample_buffer32 = av_malloc_array((fs->width + 6), 3 * MAX_PLANES *
148 : sizeof(*fs->sample_buffer32));
149 304 : if (!fs->sample_buffer || !fs->sample_buffer32) {
150 0 : av_freep(&fs->sample_buffer);
151 0 : av_freep(&fs->sample_buffer32);
152 0 : av_freep(&f->slice_context[i]);
153 0 : goto memfail;
154 : }
155 : }
156 85 : return 0;
157 :
158 0 : memfail:
159 0 : while(--i >= 0) {
160 0 : av_freep(&f->slice_context[i]->sample_buffer);
161 0 : av_freep(&f->slice_context[i]->sample_buffer32);
162 0 : av_freep(&f->slice_context[i]);
163 : }
164 0 : return AVERROR(ENOMEM);
165 : }
166 :
167 77 : int ff_ffv1_allocate_initial_states(FFV1Context *f)
168 : {
169 : int i;
170 :
171 231 : for (i = 0; i < f->quant_table_count; i++) {
172 154 : f->initial_states[i] = av_malloc_array(f->context_count[i],
173 : sizeof(*f->initial_states[i]));
174 154 : if (!f->initial_states[i])
175 0 : return AVERROR(ENOMEM);
176 154 : memset(f->initial_states[i], 128,
177 154 : f->context_count[i] * sizeof(*f->initial_states[i]));
178 : }
179 77 : return 0;
180 : }
181 :
182 1104 : void ff_ffv1_clear_slice_state(FFV1Context *f, FFV1Context *fs)
183 : {
184 : int i, j;
185 :
186 3312 : for (i = 0; i < f->plane_count; i++) {
187 2208 : PlaneContext *p = &fs->plane[i];
188 :
189 2208 : p->interlace_bit_state[0] = 128;
190 2208 : p->interlace_bit_state[1] = 128;
191 :
192 2208 : if (fs->ac != AC_GOLOMB_RICE) {
193 1056 : if (f->initial_states[p->quant_table_index]) {
194 1056 : memcpy(p->state, f->initial_states[p->quant_table_index],
195 1056 : CONTEXT_SIZE * p->context_count);
196 : } else
197 0 : memset(p->state, 128, CONTEXT_SIZE * p->context_count);
198 : } else {
199 768384 : for (j = 0; j < p->context_count; j++) {
200 767232 : p->vlc_state[j].drift = 0;
201 767232 : p->vlc_state[j].error_sum = 4; //FFMAX((RANGE + 32)/64, 2);
202 767232 : p->vlc_state[j].bias = 0;
203 767232 : p->vlc_state[j].count = 1;
204 : }
205 : }
206 : }
207 1104 : }
208 :
209 :
210 85 : av_cold int ff_ffv1_close(AVCodecContext *avctx)
211 : {
212 85 : FFV1Context *s = avctx->priv_data;
213 : int i, j;
214 :
215 85 : if (s->picture.f)
216 85 : ff_thread_release_buffer(avctx, &s->picture);
217 85 : av_frame_free(&s->picture.f);
218 :
219 85 : if (s->last_picture.f)
220 85 : ff_thread_release_buffer(avctx, &s->last_picture);
221 85 : av_frame_free(&s->last_picture.f);
222 :
223 389 : for (j = 0; j < s->max_slice_count; j++) {
224 304 : FFV1Context *fs = s->slice_context[j];
225 912 : for (i = 0; i < s->plane_count; i++) {
226 608 : PlaneContext *p = &fs->plane[i];
227 :
228 608 : av_freep(&p->state);
229 608 : av_freep(&p->vlc_state);
230 : }
231 304 : av_freep(&fs->sample_buffer);
232 304 : av_freep(&fs->sample_buffer32);
233 : }
234 :
235 85 : av_freep(&avctx->stats_out);
236 239 : for (j = 0; j < s->quant_table_count; j++) {
237 154 : av_freep(&s->initial_states[j]);
238 746 : for (i = 0; i < s->max_slice_count; i++) {
239 592 : FFV1Context *sf = s->slice_context[i];
240 592 : av_freep(&sf->rc_stat2[j]);
241 : }
242 154 : av_freep(&s->rc_stat2[j]);
243 : }
244 :
245 389 : for (i = 0; i < s->max_slice_count; i++)
246 304 : av_freep(&s->slice_context[i]);
247 :
248 85 : return 0;
249 : }
|
