FFmpeg
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-2012 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
=
avcodec_alloc_frame
();
53
s->
last_picture
.
f
=
av_frame_alloc
();
54
if
(!s->
picture
.
f
|| !s->
last_picture
.
f
)
55
return
AVERROR
(ENOMEM);
56
ff_dsputil_init
(&s->
dsp
, avctx);
57
58
s->
width
= avctx->
width
;
59
s->
height
= avctx->
height
;
60
61
// defaults
62
s->
num_h_slices
= 1;
63
s->
num_v_slices
= 1;
64
65
return
0;
66
}
67
68
av_cold
int
ffv1_init_slice_state
(
FFV1Context
*f,
FFV1Context
*fs)
69
{
70
int
j;
71
72
fs->
plane_count
= f->
plane_count
;
73
fs->
transparency
= f->
transparency
;
74
for
(j = 0; j < f->
plane_count
; j++) {
75
PlaneContext
*
const
p = &fs->
plane
[j];
76
77
if
(fs->
ac
) {
78
if
(!p->
state
)
79
p->
state
=
av_malloc
(
CONTEXT_SIZE
* p->
context_count
*
80
sizeof
(
uint8_t
));
81
if
(!p->
state
)
82
return
AVERROR
(ENOMEM);
83
}
else
{
84
if
(!p->
vlc_state
)
85
p->
vlc_state
=
av_malloc
(p->
context_count
*
sizeof
(
VlcState
));
86
if
(!p->
vlc_state
)
87
return
AVERROR
(ENOMEM);
88
}
89
}
90
91
if
(fs->
ac
> 1) {
92
//FIXME only redo if state_transition changed
93
for
(j = 1; j < 256; j++) {
94
fs->
c
. one_state[ j] = f->
state_transition
[j];
95
fs->
c
.
zero_state
[256 - j] = 256 - fs->
c
.
one_state
[j];
96
}
97
}
98
99
return
0;
100
}
101
102
av_cold
int
ffv1_init_slices_state
(
FFV1Context
*f)
103
{
104
int
i,
ret
;
105
for
(i = 0; i < f->
slice_count
; i++) {
106
FFV1Context
*fs = f->
slice_context
[i];
107
if
((ret =
ffv1_init_slice_state
(f, fs)) < 0)
108
return
AVERROR
(ENOMEM);
109
}
110
return
0;
111
}
112
113
av_cold
int
ffv1_init_slice_contexts
(
FFV1Context
*f)
114
{
115
int
i;
116
117
f->
slice_count
= f->
num_h_slices
* f->
num_v_slices
;
118
av_assert0
(f->
slice_count
> 0);
119
120
for
(i = 0; i < f->
slice_count
; i++) {
121
FFV1Context
*fs =
av_mallocz
(
sizeof
(*fs));
122
int
sx = i % f->
num_h_slices
;
123
int
sy = i / f->
num_h_slices
;
124
int
sxs = f->
avctx
->
width
* sx / f->
num_h_slices
;
125
int
sxe = f->
avctx
->
width
* (sx + 1) / f->
num_h_slices
;
126
int
sys = f->
avctx
->
height
* sy / f->
num_v_slices
;
127
int
sye = f->
avctx
->
height
* (sy + 1) / f->
num_v_slices
;
128
129
if
(!fs)
130
return
AVERROR
(ENOMEM);
131
132
f->
slice_context
[i] = fs;
133
memcpy(fs, f,
sizeof
(*fs));
134
memset(fs->
rc_stat2
, 0,
sizeof
(fs->
rc_stat2
));
135
136
fs->
slice_width
= sxe - sxs;
137
fs->
slice_height
= sye - sys;
138
fs->
slice_x
= sxs;
139
fs->
slice_y
= sys;
140
141
fs->
sample_buffer
=
av_malloc
(3 *
MAX_PLANES
* (fs->
width
+ 6) *
142
sizeof
(*fs->
sample_buffer
));
143
if
(!fs->
sample_buffer
)
144
return
AVERROR
(ENOMEM);
145
}
146
return
0;
147
}
148
149
int
ffv1_allocate_initial_states
(
FFV1Context
*f)
150
{
151
int
i;
152
153
for
(i = 0; i < f->
quant_table_count
; i++) {
154
f->
initial_states
[i] =
av_malloc
(f->
context_count
[i] *
155
sizeof
(*f->
initial_states
[i]));
156
if
(!f->
initial_states
[i])
157
return
AVERROR
(ENOMEM);
158
memset(f->
initial_states
[i], 128,
159
f->
context_count
[i] *
sizeof
(*f->
initial_states
[i]));
160
}
161
return
0;
162
}
163
164
void
ffv1_clear_slice_state
(
FFV1Context
*f,
FFV1Context
*fs)
165
{
166
int
i, j;
167
168
for
(i = 0; i < f->
plane_count
; i++) {
169
PlaneContext
*p = &fs->
plane
[i];
170
171
p->
interlace_bit_state
[0] = 128;
172
p->
interlace_bit_state
[1] = 128;
173
174
if
(fs->
ac
) {
175
if
(f->
initial_states
[p->
quant_table_index
]) {
176
memcpy(p->
state
, f->
initial_states
[p->
quant_table_index
],
177
CONTEXT_SIZE
* p->
context_count
);
178
}
else
179
memset(p->
state
, 128,
CONTEXT_SIZE
* p->
context_count
);
180
}
else
{
181
for
(j = 0; j < p->
context_count
; j++) {
182
p->
vlc_state
[j].
drift
= 0;
183
p->
vlc_state
[j].
error_sum
= 4;
//FFMAX((RANGE + 32)/64, 2);
184
p->
vlc_state
[j].
bias
= 0;
185
p->
vlc_state
[j].
count
= 1;
186
}
187
}
188
}
189
}
190
191
192
av_cold
int
ffv1_close
(
AVCodecContext
*avctx)
193
{
194
FFV1Context
*
s
= avctx->
priv_data
;
195
int
i, j;
196
197
if
(s->
picture
.
f
)
198
ff_thread_release_buffer
(avctx, &s->
picture
);
199
av_frame_free
(&s->
picture
.
f
);
200
201
if
(s->
last_picture
.
f
)
202
ff_thread_release_buffer
(avctx, &s->
last_picture
);
203
av_frame_free
(&s->
last_picture
.
f
);
204
205
for
(j = 0; j < s->
slice_count
; j++) {
206
FFV1Context
*fs = s->
slice_context
[j];
207
for
(i = 0; i < s->
plane_count
; i++) {
208
PlaneContext
*p = &fs->
plane
[i];
209
210
av_freep
(&p->
state
);
211
av_freep
(&p->
vlc_state
);
212
}
213
av_freep
(&fs->
sample_buffer
);
214
}
215
216
av_freep
(&avctx->
stats_out
);
217
for
(j = 0; j < s->
quant_table_count
; j++) {
218
av_freep
(&s->
initial_states
[j]);
219
for
(i = 0; i < s->
slice_count
; i++) {
220
FFV1Context
*sf = s->
slice_context
[i];
221
av_freep
(&sf->
rc_stat2
[j]);
222
}
223
av_freep
(&s->
rc_stat2
[j]);
224
}
225
226
for
(i = 0; i < s->
slice_count
; i++)
227
av_freep
(&s->
slice_context
[i]);
228
229
return
0;
230
}
Generated on Wed Jul 10 2013 23:47:57 for FFmpeg by
1.8.2