Line | Branch | Exec | Source |
---|---|---|---|
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/mem.h" | ||
31 | |||
32 | #include "avcodec.h" | ||
33 | #include "ffv1.h" | ||
34 | |||
35 | 111 | av_cold int ff_ffv1_common_init(AVCodecContext *avctx) | |
36 | { | ||
37 | 111 | FFV1Context *s = avctx->priv_data; | |
38 | |||
39 |
2/4✓ Branch 0 taken 111 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 111 times.
|
111 | if (!avctx->width || !avctx->height) |
40 | ✗ | return AVERROR_INVALIDDATA; | |
41 | |||
42 | 111 | s->avctx = avctx; | |
43 | 111 | s->flags = avctx->flags; | |
44 | |||
45 | 111 | s->width = avctx->width; | |
46 | 111 | s->height = avctx->height; | |
47 | |||
48 | // defaults | ||
49 | 111 | s->num_h_slices = 1; | |
50 | 111 | s->num_v_slices = 1; | |
51 | |||
52 | 111 | return 0; | |
53 | } | ||
54 | |||
55 | 12052 | av_cold int ff_ffv1_init_slice_state(const FFV1Context *f, FFV1Context *fs) | |
56 | { | ||
57 | int j, i; | ||
58 | |||
59 | 12052 | fs->plane_count = f->plane_count; | |
60 | 12052 | fs->transparency = f->transparency; | |
61 |
2/2✓ Branch 0 taken 24104 times.
✓ Branch 1 taken 12052 times.
|
36156 | for (j = 0; j < f->plane_count; j++) { |
62 | 24104 | PlaneContext *const p = &fs->plane[j]; | |
63 | |||
64 |
2/2✓ Branch 0 taken 13256 times.
✓ Branch 1 taken 10848 times.
|
24104 | if (fs->ac != AC_GOLOMB_RICE) { |
65 |
2/2✓ Branch 0 taken 712 times.
✓ Branch 1 taken 12544 times.
|
13256 | if (!p->state) |
66 | 712 | p->state = av_malloc_array(p->context_count, CONTEXT_SIZE * | |
67 | sizeof(uint8_t)); | ||
68 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 13256 times.
|
13256 | if (!p->state) |
69 | ✗ | return AVERROR(ENOMEM); | |
70 | } else { | ||
71 |
2/2✓ Branch 0 taken 566 times.
✓ Branch 1 taken 10282 times.
|
10848 | if (!p->vlc_state) { |
72 | 566 | p->vlc_state = av_calloc(p->context_count, sizeof(*p->vlc_state)); | |
73 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 566 times.
|
566 | if (!p->vlc_state) |
74 | ✗ | return AVERROR(ENOMEM); | |
75 |
2/2✓ Branch 0 taken 233100 times.
✓ Branch 1 taken 566 times.
|
233666 | for (i = 0; i < p->context_count; i++) { |
76 | 233100 | p->vlc_state[i].error_sum = 4; | |
77 | 233100 | p->vlc_state[i].count = 1; | |
78 | } | ||
79 | } | ||
80 | } | ||
81 | } | ||
82 | |||
83 |
2/2✓ Branch 0 taken 6628 times.
✓ Branch 1 taken 5424 times.
|
12052 | if (fs->ac == AC_RANGE_CUSTOM_TAB) { |
84 | //FIXME only redo if state_transition changed | ||
85 |
2/2✓ Branch 0 taken 1690140 times.
✓ Branch 1 taken 6628 times.
|
1696768 | for (j = 1; j < 256; j++) { |
86 | 1690140 | fs->c. one_state[ j] = f->state_transition[j]; | |
87 | 1690140 | fs->c.zero_state[256 - j] = 256 - fs->c.one_state[j]; | |
88 | } | ||
89 | } | ||
90 | |||
91 | 12052 | return 0; | |
92 | } | ||
93 | |||
94 | 39 | av_cold int ff_ffv1_init_slices_state(FFV1Context *f) | |
95 | { | ||
96 | int i, ret; | ||
97 |
2/2✓ Branch 0 taken 141 times.
✓ Branch 1 taken 39 times.
|
180 | for (i = 0; i < f->max_slice_count; i++) { |
98 | 141 | FFV1Context *fs = f->slice_context[i]; | |
99 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 141 times.
|
141 | if ((ret = ff_ffv1_init_slice_state(f, fs)) < 0) |
100 | ✗ | return AVERROR(ENOMEM); | |
101 | } | ||
102 | 39 | return 0; | |
103 | } | ||
104 | |||
105 | 111 | av_cold int ff_ffv1_init_slice_contexts(FFV1Context *f) | |
106 | { | ||
107 | 111 | int i, max_slice_count = f->num_h_slices * f->num_v_slices; | |
108 | |||
109 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 111 times.
|
111 | av_assert0(max_slice_count > 0); |
110 | |||
111 |
2/2✓ Branch 0 taken 399 times.
✓ Branch 1 taken 111 times.
|
510 | for (i = 0; i < max_slice_count;) { |
112 | 399 | int sx = i % f->num_h_slices; | |
113 | 399 | int sy = i / f->num_h_slices; | |
114 | 399 | int sxs = f->avctx->width * sx / f->num_h_slices; | |
115 | 399 | int sxe = f->avctx->width * (sx + 1) / f->num_h_slices; | |
116 | 399 | int sys = f->avctx->height * sy / f->num_v_slices; | |
117 | 399 | int sye = f->avctx->height * (sy + 1) / f->num_v_slices; | |
118 | 399 | FFV1Context *fs = av_mallocz(sizeof(*fs)); | |
119 | |||
120 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 399 times.
|
399 | if (!fs) |
121 | ✗ | goto memfail; | |
122 | |||
123 | 399 | f->slice_context[i++] = fs; | |
124 | 399 | memcpy(fs, f, sizeof(*fs)); | |
125 | 399 | memset(fs->rc_stat2, 0, sizeof(fs->rc_stat2)); | |
126 | |||
127 | 399 | fs->slice_width = sxe - sxs; | |
128 | 399 | fs->slice_height = sye - sys; | |
129 | 399 | fs->slice_x = sxs; | |
130 | 399 | fs->slice_y = sys; | |
131 | |||
132 | 399 | fs->sample_buffer = av_malloc_array((fs->width + 6), 3 * MAX_PLANES * | |
133 | sizeof(*fs->sample_buffer)); | ||
134 | 399 | fs->sample_buffer32 = av_malloc_array((fs->width + 6), 3 * MAX_PLANES * | |
135 | sizeof(*fs->sample_buffer32)); | ||
136 |
2/4✓ Branch 0 taken 399 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 399 times.
|
399 | if (!fs->sample_buffer || !fs->sample_buffer32) |
137 | ✗ | goto memfail; | |
138 | } | ||
139 | 111 | f->max_slice_count = max_slice_count; | |
140 | 111 | return 0; | |
141 | |||
142 | ✗ | memfail: | |
143 | ✗ | f->max_slice_count = i; | |
144 | ✗ | return AVERROR(ENOMEM); | |
145 | } | ||
146 | |||
147 | 101 | int ff_ffv1_allocate_initial_states(FFV1Context *f) | |
148 | { | ||
149 | int i; | ||
150 | |||
151 |
2/2✓ Branch 0 taken 202 times.
✓ Branch 1 taken 101 times.
|
303 | for (i = 0; i < f->quant_table_count; i++) { |
152 | 202 | f->initial_states[i] = av_malloc_array(f->context_count[i], | |
153 | sizeof(*f->initial_states[i])); | ||
154 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 202 times.
|
202 | if (!f->initial_states[i]) |
155 | ✗ | return AVERROR(ENOMEM); | |
156 | 202 | memset(f->initial_states[i], 128, | |
157 | 202 | f->context_count[i] * sizeof(*f->initial_states[i])); | |
158 | } | ||
159 | 101 | return 0; | |
160 | } | ||
161 | |||
162 | 1411 | void ff_ffv1_clear_slice_state(const FFV1Context *f, FFV1Context *fs) | |
163 | { | ||
164 | int i, j; | ||
165 | |||
166 |
2/2✓ Branch 0 taken 2822 times.
✓ Branch 1 taken 1411 times.
|
4233 | for (i = 0; i < f->plane_count; i++) { |
167 | 2822 | PlaneContext *p = &fs->plane[i]; | |
168 | |||
169 | 2822 | p->interlace_bit_state[0] = 128; | |
170 | 2822 | p->interlace_bit_state[1] = 128; | |
171 | |||
172 |
2/2✓ Branch 0 taken 1592 times.
✓ Branch 1 taken 1230 times.
|
2822 | if (fs->ac != AC_GOLOMB_RICE) { |
173 |
1/2✓ Branch 0 taken 1592 times.
✗ Branch 1 not taken.
|
1592 | if (f->initial_states[p->quant_table_index]) { |
174 | 1592 | memcpy(p->state, f->initial_states[p->quant_table_index], | |
175 | 1592 | CONTEXT_SIZE * p->context_count); | |
176 | } else | ||
177 | ✗ | memset(p->state, 128, CONTEXT_SIZE * p->context_count); | |
178 | } else { | ||
179 |
2/2✓ Branch 0 taken 819180 times.
✓ Branch 1 taken 1230 times.
|
820410 | for (j = 0; j < p->context_count; j++) { |
180 | 819180 | p->vlc_state[j].drift = 0; | |
181 | 819180 | p->vlc_state[j].error_sum = 4; //FFMAX((RANGE + 32)/64, 2); | |
182 | 819180 | p->vlc_state[j].bias = 0; | |
183 | 819180 | p->vlc_state[j].count = 1; | |
184 | } | ||
185 | } | ||
186 | } | ||
187 | 1411 | } | |
188 | |||
189 | |||
190 | 111 | av_cold int ff_ffv1_close(AVCodecContext *avctx) | |
191 | { | ||
192 | 111 | FFV1Context *s = avctx->priv_data; | |
193 | int i, j; | ||
194 | |||
195 |
2/2✓ Branch 0 taken 399 times.
✓ Branch 1 taken 111 times.
|
510 | for (j = 0; j < s->max_slice_count; j++) { |
196 | 399 | FFV1Context *fs = s->slice_context[j]; | |
197 |
2/2✓ Branch 0 taken 798 times.
✓ Branch 1 taken 399 times.
|
1197 | for (i = 0; i < s->plane_count; i++) { |
198 | 798 | PlaneContext *p = &fs->plane[i]; | |
199 | |||
200 | 798 | av_freep(&p->state); | |
201 | 798 | av_freep(&p->vlc_state); | |
202 | } | ||
203 | 399 | av_freep(&fs->sample_buffer); | |
204 | 399 | av_freep(&fs->sample_buffer32); | |
205 | } | ||
206 | |||
207 | 111 | av_freep(&avctx->stats_out); | |
208 |
2/2✓ Branch 0 taken 202 times.
✓ Branch 1 taken 111 times.
|
313 | for (j = 0; j < s->quant_table_count; j++) { |
209 | 202 | av_freep(&s->initial_states[j]); | |
210 |
2/2✓ Branch 0 taken 778 times.
✓ Branch 1 taken 202 times.
|
980 | for (i = 0; i < s->max_slice_count; i++) { |
211 | 778 | FFV1Context *sf = s->slice_context[i]; | |
212 | 778 | av_freep(&sf->rc_stat2[j]); | |
213 | } | ||
214 | 202 | av_freep(&s->rc_stat2[j]); | |
215 | } | ||
216 | |||
217 |
2/2✓ Branch 0 taken 399 times.
✓ Branch 1 taken 111 times.
|
510 | for (i = 0; i < s->max_slice_count; i++) |
218 | 399 | av_freep(&s->slice_context[i]); | |
219 | |||
220 | 111 | return 0; | |
221 | } | ||
222 |