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 #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 
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();
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 
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 != AC_GOLOMB_RICE) {
77  if (!p->state)
79  sizeof(uint8_t));
80  if (!p->state)
81  return AVERROR(ENOMEM);
82  } else {
83  if (!p->vlc_state) {
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 == AC_RANGE_CUSTOM_TAB) {
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 
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 = ff_ffv1_init_slice_state(f, fs)) < 0)
112  return AVERROR(ENOMEM);
113  }
114  return 0;
115 }
116 
118 {
119  int i;
120 
122  av_assert0(f->max_slice_count > 0);
123 
124  for (i = 0; i < f->max_slice_count; i++) {
125  int sx = i % f->num_h_slices;
126  int sy = i / f->num_h_slices;
127  int sxs = f->avctx->width * sx / f->num_h_slices;
128  int sxe = f->avctx->width * (sx + 1) / f->num_h_slices;
129  int sys = f->avctx->height * sy / f->num_v_slices;
130  int sye = f->avctx->height * (sy + 1) / f->num_v_slices;
131  FFV1Context *fs = av_mallocz(sizeof(*fs));
132 
133  if (!fs)
134  goto memfail;
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  fs->sample_buffer32 = av_malloc_array((fs->width + 6), 3 * MAX_PLANES *
148  sizeof(*fs->sample_buffer32));
149  if (!fs->sample_buffer || !fs->sample_buffer32) {
150  av_freep(&fs->sample_buffer);
152  av_freep(&f->slice_context[i]);
153  goto memfail;
154  }
155  }
156  return 0;
157 
158 memfail:
159  while(--i >= 0) {
162  av_freep(&f->slice_context[i]);
163  }
164  return AVERROR(ENOMEM);
165 }
166 
168 {
169  int i;
170 
171  for (i = 0; i < f->quant_table_count; i++) {
173  sizeof(*f->initial_states[i]));
174  if (!f->initial_states[i])
175  return AVERROR(ENOMEM);
176  memset(f->initial_states[i], 128,
177  f->context_count[i] * sizeof(*f->initial_states[i]));
178  }
179  return 0;
180 }
181 
183 {
184  int i, j;
185 
186  for (i = 0; i < f->plane_count; i++) {
187  PlaneContext *p = &fs->plane[i];
188 
189  p->interlace_bit_state[0] = 128;
190  p->interlace_bit_state[1] = 128;
191 
192  if (fs->ac != AC_GOLOMB_RICE) {
193  if (f->initial_states[p->quant_table_index]) {
194  memcpy(p->state, f->initial_states[p->quant_table_index],
196  } else
197  memset(p->state, 128, CONTEXT_SIZE * p->context_count);
198  } else {
199  for (j = 0; j < p->context_count; j++) {
200  p->vlc_state[j].drift = 0;
201  p->vlc_state[j].error_sum = 4; //FFMAX((RANGE + 32)/64, 2);
202  p->vlc_state[j].bias = 0;
203  p->vlc_state[j].count = 1;
204  }
205  }
206  }
207 }
208 
209 
211 {
212  FFV1Context *s = avctx->priv_data;
213  int i, j;
214 
215  if (s->picture.f)
216  ff_thread_release_buffer(avctx, &s->picture);
217  av_frame_free(&s->picture.f);
218 
219  if (s->last_picture.f)
222 
223  for (j = 0; j < s->max_slice_count; j++) {
224  FFV1Context *fs = s->slice_context[j];
225  for (i = 0; i < s->plane_count; i++) {
226  PlaneContext *p = &fs->plane[i];
227 
228  av_freep(&p->state);
229  av_freep(&p->vlc_state);
230  }
231  av_freep(&fs->sample_buffer);
233  }
234 
235  av_freep(&avctx->stats_out);
236  for (j = 0; j < s->quant_table_count; j++) {
237  av_freep(&s->initial_states[j]);
238  for (i = 0; i < s->max_slice_count; i++) {
239  FFV1Context *sf = s->slice_context[i];
240  av_freep(&sf->rc_stat2[j]);
241  }
242  av_freep(&s->rc_stat2[j]);
243  }
244 
245  for (i = 0; i < s->max_slice_count; i++)
246  av_freep(&s->slice_context[i]);
247 
248  return 0;
249 }
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
int flags
Definition: ffv1.h:93
misc image utilities
AVFrame * f
Definition: thread.h:35
int quant_table_count
Definition: ffv1.h:126
int slice_height
Definition: ffv1.h:134
int16_t * sample_buffer
Definition: ffv1.h:111
uint8_t zero_state[256]
Definition: rangecoder.h:40
Range coder.
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:236
uint64_t(*[MAX_QUANT_TABLES] rc_stat2)[32][2]
Definition: ffv1.h:86
FF Video Codec 1 (a lossless codec)
int height
Definition: ffv1.h:89
uint8_t one_state[256]
Definition: rangecoder.h:41
Macro definitions for various function/variable attributes.
int plane_count
Definition: ffv1.h:100
ThreadFrame picture
Definition: ffv1.h:96
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
uint8_t
#define av_cold
Definition: attributes.h:82
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:189
#define fs(width, name, subs,...)
Definition: cbs_vp9.c:259
AVOptions.
int8_t bias
Definition: ffv1.h:64
#define f(width, name)
Definition: cbs_vp9.c:255
RangeCoder c
Definition: ffv1.h:82
av_cold int ff_ffv1_common_init(AVCodecContext *avctx)
Definition: ffv1.c:42
int slice_y
Definition: ffv1.h:136
uint8_t(*[MAX_QUANT_TABLES] initial_states)[32]
Definition: ffv1.h:108
ThreadFrame last_picture
Definition: ffv1.h:96
Public header for CRC hash function implementation.
av_cold int ff_ffv1_close(AVCodecContext *avctx)
Definition: ffv1.c:210
uint8_t count
Definition: ffv1.h:65
VlcState * vlc_state
Definition: ffv1.h:73
char * stats_out
pass1 encoding statistics output buffer
Definition: avcodec.h:2584
high precision timer, useful to profile code
int slice_width
Definition: ffv1.h:133
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
av_cold int ff_ffv1_init_slices_state(FFV1Context *f)
Definition: ffv1.c:106
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:202
int context_count
Definition: ffv1.h:71
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1645
simple assert() macros that are a bit more flexible than ISO C assert().
int ff_ffv1_allocate_initial_states(FFV1Context *f)
Definition: ffv1.c:167
int ac
1=range coder <-> 0=golomb rice
Definition: ffv1.h:101
#define AC_RANGE_CUSTOM_TAB
Definition: ffv1.h:58
Definition: ffv1.h:61
uint8_t state_transition[256]
Definition: ffv1.h:107
int num_h_slices
Definition: ffv1.h:132
int width
picture width / height.
Definition: avcodec.h:1738
#define MAX_PLANES
Definition: ffv1.h:50
int max_slice_count
Definition: ffv1.h:130
#define s(width, name)
Definition: cbs_vp9.c:257
av_cold int ff_ffv1_init_slice_contexts(FFV1Context *f)
Definition: ffv1.c:117
av_cold int ff_ffv1_init_slice_state(FFV1Context *f, FFV1Context *fs)
Definition: ffv1.c:67
int16_t drift
Definition: ffv1.h:62
int context_count[MAX_QUANT_TABLES]
Definition: ffv1.h:106
Libavcodec external API header.
the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before as well as code calling up to before the decode process starts Call have add an so the codec calls ff_thread_report set AVCodecInternal allocate_progress The frames must then be freed with ff_thread_release_buffer().Otherwise leave it at zero and decode directly into the user-supplied frames.Call ff_thread_report_progress() after some part of the current picture has decoded.A good place to put this is where draw_horiz_band() is called-add this if it isn't called anywhere
main external API structure.
Definition: avcodec.h:1565
#define AC_GOLOMB_RICE
Definition: ffv1.h:56
uint16_t error_sum
Definition: ffv1.h:63
int32_t * sample_buffer32
Definition: ffv1.h:112
#define CONTEXT_SIZE
Definition: ffv1.h:51
int quant_table_index
Definition: ffv1.h:70
common internal api header.
void ff_ffv1_clear_slice_state(FFV1Context *f, FFV1Context *fs)
Definition: ffv1.c:182
uint8_t(* state)[CONTEXT_SIZE]
Definition: ffv1.h:72
void * priv_data
Definition: avcodec.h:1592
PlaneContext plane[MAX_PLANES]
Definition: ffv1.h:103
int transparency
Definition: ffv1.h:92
struct FFV1Context * slice_context[MAX_SLICES]
Definition: ffv1.h:128
uint8_t interlace_bit_state[2]
Definition: ffv1.h:74
#define av_freep(p)
#define av_malloc_array(a, b)
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
int num_v_slices
Definition: ffv1.h:131
AVCodecContext * avctx
Definition: ffv1.h:81
int slice_x
Definition: ffv1.h:135
int width
Definition: ffv1.h:89
void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.c:191