FFmpeg
2.6.9
Main Page
Related Pages
Modules
Namespaces
Data Structures
Files
Examples
File List
Globals
All
Data Structures
Namespaces
Files
Functions
Variables
Typedefs
Enumerations
Enumerator
Macros
Groups
Pages
libavcodec
ffv1.c
Go to the documentation of this file.
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
#include "
avcodec.h
"
36
#include "
internal.h
"
37
#include "
rangecoder.h
"
38
#include "
golomb.h
"
39
#include "
mathops.h
"
40
#include "
ffv1.h
"
41
42
av_cold
int
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
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
) {
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
> 1) {
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
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 =
ffv1_init_slice_state
(f, fs)) < 0)
112
return
AVERROR
(ENOMEM);
113
}
114
return
0;
115
}
116
117
av_cold
int
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
FFV1Context
*fs =
av_mallocz
(
sizeof
(*fs));
126
int
sx = i % f->
num_h_slices
;
127
int
sy = i / f->
num_h_slices
;
128
int
sxs = f->
avctx
->
width
* sx / f->
num_h_slices
;
129
int
sxe = f->
avctx
->
width
* (sx + 1) / f->
num_h_slices
;
130
int
sys = f->
avctx
->
height
* sy / f->
num_v_slices
;
131
int
sye = f->
avctx
->
height
* (sy + 1) / f->
num_v_slices
;
132
133
if
(!fs)
134
return
AVERROR
(ENOMEM);
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
if
(!fs->
sample_buffer
)
148
return
AVERROR
(ENOMEM);
149
}
150
return
0;
151
}
152
153
int
ffv1_allocate_initial_states
(
FFV1Context
*f)
154
{
155
int
i;
156
157
for
(i = 0; i < f->
quant_table_count
; i++) {
158
f->
initial_states
[i] =
av_malloc_array
(f->
context_count
[i],
159
sizeof
(*f->
initial_states
[i]));
160
if
(!f->
initial_states
[i])
161
return
AVERROR
(ENOMEM);
162
memset(f->
initial_states
[i], 128,
163
f->
context_count
[i] *
sizeof
(*f->
initial_states
[i]));
164
}
165
return
0;
166
}
167
168
void
ffv1_clear_slice_state
(
FFV1Context
*f,
FFV1Context
*fs)
169
{
170
int
i, j;
171
172
for
(i = 0; i < f->
plane_count
; i++) {
173
PlaneContext
*p = &fs->
plane
[i];
174
175
p->
interlace_bit_state
[0] = 128;
176
p->
interlace_bit_state
[1] = 128;
177
178
if
(fs->
ac
) {
179
if
(f->
initial_states
[p->
quant_table_index
]) {
180
memcpy(p->
state
, f->
initial_states
[p->
quant_table_index
],
181
CONTEXT_SIZE
* p->
context_count
);
182
}
else
183
memset(p->
state
, 128,
CONTEXT_SIZE
* p->
context_count
);
184
}
else
{
185
for
(j = 0; j < p->
context_count
; j++) {
186
p->
vlc_state
[j].
drift
= 0;
187
p->
vlc_state
[j].
error_sum
= 4;
//FFMAX((RANGE + 32)/64, 2);
188
p->
vlc_state
[j].
bias
= 0;
189
p->
vlc_state
[j].
count
= 1;
190
}
191
}
192
}
193
}
194
195
196
av_cold
int
ffv1_close
(
AVCodecContext
*avctx)
197
{
198
FFV1Context
*
s
= avctx->
priv_data
;
199
int
i, j;
200
201
if
(s->
picture
.
f
)
202
ff_thread_release_buffer
(avctx, &s->
picture
);
203
av_frame_free
(&s->
picture
.
f
);
204
205
if
(s->
last_picture
.
f
)
206
ff_thread_release_buffer
(avctx, &s->
last_picture
);
207
av_frame_free
(&s->
last_picture
.
f
);
208
209
for
(j = 0; j < s->
max_slice_count
; j++) {
210
FFV1Context
*fs = s->
slice_context
[j];
211
for
(i = 0; i < s->
plane_count
; i++) {
212
PlaneContext
*p = &fs->
plane
[i];
213
214
av_freep
(&p->
state
);
215
av_freep
(&p->
vlc_state
);
216
}
217
av_freep
(&fs->
sample_buffer
);
218
}
219
220
av_freep
(&avctx->
stats_out
);
221
for
(j = 0; j < s->
quant_table_count
; j++) {
222
av_freep
(&s->
initial_states
[j]);
223
for
(i = 0; i < s->
max_slice_count
; i++) {
224
FFV1Context
*sf = s->
slice_context
[i];
225
av_freep
(&sf->
rc_stat2
[j]);
226
}
227
av_freep
(&s->
rc_stat2
[j]);
228
}
229
230
for
(i = 0; i < s->
max_slice_count
; i++)
231
av_freep
(&s->
slice_context
[i]);
232
233
return
0;
234
}
Generated on Thu Sep 30 2021 22:46:58 for FFmpeg by
1.8.1.2