FFmpeg
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 
31 #include "avcodec.h"
32 #include "rangecoder.h"
33 #include "ffv1.h"
34 #include "threadframe.h"
35 
37 {
38  FFV1Context *s = avctx->priv_data;
39 
40  if (!avctx->width || !avctx->height)
41  return AVERROR_INVALIDDATA;
42 
43  s->avctx = avctx;
44  s->flags = avctx->flags;
45 
46  s->picture.f = av_frame_alloc();
47  s->last_picture.f = av_frame_alloc();
48  if (!s->picture.f || !s->last_picture.f)
49  return AVERROR(ENOMEM);
50 
51  s->width = avctx->width;
52  s->height = avctx->height;
53 
54  // defaults
55  s->num_h_slices = 1;
56  s->num_v_slices = 1;
57 
58  return 0;
59 }
60 
62 {
63  int j, i;
64 
65  fs->plane_count = f->plane_count;
66  fs->transparency = f->transparency;
67  for (j = 0; j < f->plane_count; j++) {
68  PlaneContext *const p = &fs->plane[j];
69 
70  if (fs->ac != AC_GOLOMB_RICE) {
71  if (!p->state)
73  sizeof(uint8_t));
74  if (!p->state)
75  return AVERROR(ENOMEM);
76  } else {
77  if (!p->vlc_state) {
78  p->vlc_state = av_calloc(p->context_count, sizeof(*p->vlc_state));
79  if (!p->vlc_state)
80  return AVERROR(ENOMEM);
81  for (i = 0; i < p->context_count; i++) {
82  p->vlc_state[i].error_sum = 4;
83  p->vlc_state[i].count = 1;
84  }
85  }
86  }
87  }
88 
89  if (fs->ac == AC_RANGE_CUSTOM_TAB) {
90  //FIXME only redo if state_transition changed
91  for (j = 1; j < 256; j++) {
92  fs->c. one_state[ j] = f->state_transition[j];
93  fs->c.zero_state[256 - j] = 256 - fs->c.one_state[j];
94  }
95  }
96 
97  return 0;
98 }
99 
101 {
102  int i, ret;
103  for (i = 0; i < f->max_slice_count; i++) {
104  FFV1Context *fs = f->slice_context[i];
105  if ((ret = ff_ffv1_init_slice_state(f, fs)) < 0)
106  return AVERROR(ENOMEM);
107  }
108  return 0;
109 }
110 
112 {
113  int i, max_slice_count = f->num_h_slices * f->num_v_slices;
114 
115  av_assert0(max_slice_count > 0);
116 
117  for (i = 0; i < max_slice_count;) {
118  int sx = i % f->num_h_slices;
119  int sy = i / f->num_h_slices;
120  int sxs = f->avctx->width * sx / f->num_h_slices;
121  int sxe = f->avctx->width * (sx + 1) / f->num_h_slices;
122  int sys = f->avctx->height * sy / f->num_v_slices;
123  int sye = f->avctx->height * (sy + 1) / f->num_v_slices;
124  FFV1Context *fs = av_mallocz(sizeof(*fs));
125 
126  if (!fs)
127  goto memfail;
128 
129  f->slice_context[i++] = fs;
130  memcpy(fs, f, sizeof(*fs));
131  memset(fs->rc_stat2, 0, sizeof(fs->rc_stat2));
132 
133  fs->slice_width = sxe - sxs;
134  fs->slice_height = sye - sys;
135  fs->slice_x = sxs;
136  fs->slice_y = sys;
137 
138  fs->sample_buffer = av_malloc_array((fs->width + 6), 3 * MAX_PLANES *
139  sizeof(*fs->sample_buffer));
140  fs->sample_buffer32 = av_malloc_array((fs->width + 6), 3 * MAX_PLANES *
141  sizeof(*fs->sample_buffer32));
142  if (!fs->sample_buffer || !fs->sample_buffer32)
143  goto memfail;
144  }
145  f->max_slice_count = max_slice_count;
146  return 0;
147 
148 memfail:
149  f->max_slice_count = i;
150  return AVERROR(ENOMEM);
151 }
152 
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 
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 != AC_GOLOMB_RICE) {
179  if (f->initial_states[p->quant_table_index]) {
180  memcpy(p->state, f->initial_states[p->quant_table_index],
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 
197 {
198  FFV1Context *s = avctx->priv_data;
199  int i, j;
200 
201  if (s->picture.f)
202  ff_thread_release_ext_buffer(avctx, &s->picture);
203  av_frame_free(&s->picture.f);
204 
205  if (s->last_picture.f)
206  ff_thread_release_ext_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  av_freep(&fs->sample_buffer32);
219  }
220 
221  av_freep(&avctx->stats_out);
222  for (j = 0; j < s->quant_table_count; j++) {
223  av_freep(&s->initial_states[j]);
224  for (i = 0; i < s->max_slice_count; i++) {
225  FFV1Context *sf = s->slice_context[i];
226  av_freep(&sf->rc_stat2[j]);
227  }
228  av_freep(&s->rc_stat2[j]);
229  }
230 
231  for (i = 0; i < s->max_slice_count; i++)
232  av_freep(&s->slice_context[i]);
233 
234  return 0;
235 }
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
ff_thread_release_ext_buffer
void ff_thread_release_ext_buffer(AVCodecContext *avctx, ThreadFrame *f)
Unref a ThreadFrame.
Definition: pthread_frame.c:1141
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:116
ff_ffv1_common_init
av_cold int ff_ffv1_common_init(AVCodecContext *avctx)
Definition: ffv1.c:36
rangecoder.h
PlaneContext::state
uint8_t(* state)[CONTEXT_SIZE]
Definition: ffv1.h:66
AC_RANGE_CUSTOM_TAB
#define AC_RANGE_CUSTOM_TAB
Definition: ffv1.h:52
ff_ffv1_init_slices_state
av_cold int ff_ffv1_init_slices_state(FFV1Context *f)
Definition: ffv1.c:100
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:478
CONTEXT_SIZE
#define CONTEXT_SIZE
Definition: ffv1.h:45
PlaneContext::context_count
int context_count
Definition: ffv1.h:65
ff_ffv1_clear_slice_state
void ff_ffv1_clear_slice_state(const FFV1Context *f, FFV1Context *fs)
Definition: ffv1.c:168
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:104
avassert.h
av_cold
#define av_cold
Definition: attributes.h:90
s
#define s(width, name)
Definition: cbs_vp9.c:256
MAX_PLANES
#define MAX_PLANES
Definition: ffv1.h:44
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
VlcState::error_sum
uint16_t error_sum
Definition: ffv1.h:57
PlaneContext::interlace_bit_state
uint8_t interlace_bit_state[2]
Definition: ffv1.h:68
threadframe.h
PlaneContext::vlc_state
VlcState * vlc_state
Definition: ffv1.h:67
AC_GOLOMB_RICE
#define AC_GOLOMB_RICE
Definition: ffv1.h:50
fs
#define fs(width, name, subs,...)
Definition: cbs_vp9.c:258
PlaneContext
Definition: ffv1.h:62
AVCodecContext::stats_out
char * stats_out
pass1 encoding statistics output buffer
Definition: avcodec.h:1265
f
f
Definition: af_crystalizer.c:122
ff_ffv1_close
av_cold int ff_ffv1_close(AVCodecContext *avctx)
Definition: ffv1.c:196
VlcState::count
uint8_t count
Definition: ffv1.h:59
attributes.h
PlaneContext::quant_table_index
int quant_table_index
Definition: ffv1.h:64
VlcState::drift
int16_t drift
Definition: ffv1.h:56
ff_ffv1_init_slice_state
av_cold int ff_ffv1_init_slice_state(const FFV1Context *f, FFV1Context *fs)
Definition: ffv1.c:61
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:31
ffv1.h
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:264
AVCodecContext::height
int height
Definition: avcodec.h:571
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:272
avcodec.h
ret
ret
Definition: filter_design.txt:187
FFV1Context::rc_stat2
uint64_t(*[MAX_QUANT_TABLES] rc_stat2)[32][2]
Definition: ffv1.h:80
ff_ffv1_allocate_initial_states
int ff_ffv1_allocate_initial_states(FFV1Context *f)
Definition: ffv1.c:153
AVCodecContext
main external API structure.
Definition: avcodec.h:398
VlcState::bias
int8_t bias
Definition: ffv1.h:58
FFV1Context
Definition: ffv1.h:73
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:425
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:571
ff_ffv1_init_slice_contexts
av_cold int ff_ffv1_init_slice_contexts(FFV1Context *f)
Definition: ffv1.c:111
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61