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 
35 #include "avcodec.h"
36 #include "internal.h"
37 #include "rangecoder.h"
38 #include "mathops.h"
39 #include "ffv1.h"
40 
42 {
43  FFV1Context *s = avctx->priv_data;
44 
45  if (!avctx->width || !avctx->height)
46  return AVERROR_INVALIDDATA;
47 
48  s->avctx = avctx;
49  s->flags = avctx->flags;
50 
51  s->picture.f = av_frame_alloc();
53  if (!s->picture.f || !s->last_picture.f)
54  return AVERROR(ENOMEM);
55 
56  s->width = avctx->width;
57  s->height = avctx->height;
58 
59  // defaults
60  s->num_h_slices = 1;
61  s->num_v_slices = 1;
62 
63  return 0;
64 }
65 
67 {
68  int j, i;
69 
70  fs->plane_count = f->plane_count;
71  fs->transparency = f->transparency;
72  for (j = 0; j < f->plane_count; j++) {
73  PlaneContext *const p = &fs->plane[j];
74 
75  if (fs->ac != AC_GOLOMB_RICE) {
76  if (!p->state)
78  sizeof(uint8_t));
79  if (!p->state)
80  return AVERROR(ENOMEM);
81  } else {
82  if (!p->vlc_state) {
84  if (!p->vlc_state)
85  return AVERROR(ENOMEM);
86  for (i = 0; i < p->context_count; i++) {
87  p->vlc_state[i].error_sum = 4;
88  p->vlc_state[i].count = 1;
89  }
90  }
91  }
92  }
93 
94  if (fs->ac == AC_RANGE_CUSTOM_TAB) {
95  //FIXME only redo if state_transition changed
96  for (j = 1; j < 256; j++) {
97  fs->c. one_state[ j] = f->state_transition[j];
98  fs->c.zero_state[256 - j] = 256 - fs->c.one_state[j];
99  }
100  }
101 
102  return 0;
103 }
104 
106 {
107  int i, ret;
108  for (i = 0; i < f->max_slice_count; i++) {
109  FFV1Context *fs = f->slice_context[i];
110  if ((ret = ff_ffv1_init_slice_state(f, fs)) < 0)
111  return AVERROR(ENOMEM);
112  }
113  return 0;
114 }
115 
117 {
118  int i, max_slice_count = f->num_h_slices * f->num_v_slices;
119 
120  av_assert0(max_slice_count > 0);
121 
122  for (i = 0; i < max_slice_count;) {
123  int sx = i % f->num_h_slices;
124  int sy = i / f->num_h_slices;
125  int sxs = f->avctx->width * sx / f->num_h_slices;
126  int sxe = f->avctx->width * (sx + 1) / f->num_h_slices;
127  int sys = f->avctx->height * sy / f->num_v_slices;
128  int sye = f->avctx->height * (sy + 1) / f->num_v_slices;
129  FFV1Context *fs = av_mallocz(sizeof(*fs));
130 
131  if (!fs)
132  goto memfail;
133 
134  f->slice_context[i++] = fs;
135  memcpy(fs, f, sizeof(*fs));
136  memset(fs->rc_stat2, 0, sizeof(fs->rc_stat2));
137 
138  fs->slice_width = sxe - sxs;
139  fs->slice_height = sye - sys;
140  fs->slice_x = sxs;
141  fs->slice_y = sys;
142 
143  fs->sample_buffer = av_malloc_array((fs->width + 6), 3 * MAX_PLANES *
144  sizeof(*fs->sample_buffer));
145  fs->sample_buffer32 = av_malloc_array((fs->width + 6), 3 * MAX_PLANES *
146  sizeof(*fs->sample_buffer32));
147  if (!fs->sample_buffer || !fs->sample_buffer32)
148  goto memfail;
149  }
150  f->max_slice_count = max_slice_count;
151  return 0;
152 
153 memfail:
154  f->max_slice_count = i;
155  return AVERROR(ENOMEM);
156 }
157 
159 {
160  int i;
161 
162  for (i = 0; i < f->quant_table_count; i++) {
164  sizeof(*f->initial_states[i]));
165  if (!f->initial_states[i])
166  return AVERROR(ENOMEM);
167  memset(f->initial_states[i], 128,
168  f->context_count[i] * sizeof(*f->initial_states[i]));
169  }
170  return 0;
171 }
172 
174 {
175  int i, j;
176 
177  for (i = 0; i < f->plane_count; i++) {
178  PlaneContext *p = &fs->plane[i];
179 
180  p->interlace_bit_state[0] = 128;
181  p->interlace_bit_state[1] = 128;
182 
183  if (fs->ac != AC_GOLOMB_RICE) {
184  if (f->initial_states[p->quant_table_index]) {
185  memcpy(p->state, f->initial_states[p->quant_table_index],
187  } else
188  memset(p->state, 128, CONTEXT_SIZE * p->context_count);
189  } else {
190  for (j = 0; j < p->context_count; j++) {
191  p->vlc_state[j].drift = 0;
192  p->vlc_state[j].error_sum = 4; //FFMAX((RANGE + 32)/64, 2);
193  p->vlc_state[j].bias = 0;
194  p->vlc_state[j].count = 1;
195  }
196  }
197  }
198 }
199 
200 
202 {
203  FFV1Context *s = avctx->priv_data;
204  int i, j;
205 
206  if (s->picture.f)
207  ff_thread_release_buffer(avctx, &s->picture);
208  av_frame_free(&s->picture.f);
209 
210  if (s->last_picture.f)
213 
214  for (j = 0; j < s->max_slice_count; j++) {
215  FFV1Context *fs = s->slice_context[j];
216  for (i = 0; i < s->plane_count; i++) {
217  PlaneContext *p = &fs->plane[i];
218 
219  av_freep(&p->state);
220  av_freep(&p->vlc_state);
221  }
222  av_freep(&fs->sample_buffer);
224  }
225 
226  av_freep(&avctx->stats_out);
227  for (j = 0; j < s->quant_table_count; j++) {
228  av_freep(&s->initial_states[j]);
229  for (i = 0; i < s->max_slice_count; i++) {
230  FFV1Context *sf = s->slice_context[i];
231  av_freep(&sf->rc_stat2[j]);
232  }
233  av_freep(&s->rc_stat2[j]);
234  }
235 
236  for (i = 0; i < s->max_slice_count; i++)
237  av_freep(&s->slice_context[i]);
238 
239  return 0;
240 }
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
int flags
Definition: ffv1.h:92
misc image utilities
AVFrame * f
Definition: thread.h:35
int quant_table_count
Definition: ffv1.h:125
int slice_height
Definition: ffv1.h:133
int16_t * sample_buffer
Definition: ffv1.h:110
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:237
uint64_t(*[MAX_QUANT_TABLES] rc_stat2)[32][2]
Definition: ffv1.h:85
FF Video Codec 1 (a lossless codec)
int height
Definition: ffv1.h:88
uint8_t one_state[256]
Definition: rangecoder.h:41
Macro definitions for various function/variable attributes.
int plane_count
Definition: ffv1.h:99
ThreadFrame picture
Definition: ffv1.h:95
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
uint8_t
#define av_cold
Definition: attributes.h:88
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:190
#define fs(width, name, subs,...)
Definition: cbs_vp9.c:259
AVOptions.
int8_t bias
Definition: ffv1.h:63
#define f(width, name)
Definition: cbs_vp9.c:255
RangeCoder c
Definition: ffv1.h:81
av_cold int ff_ffv1_common_init(AVCodecContext *avctx)
Definition: ffv1.c:41
int slice_y
Definition: ffv1.h:135
uint8_t(*[MAX_QUANT_TABLES] initial_states)[32]
Definition: ffv1.h:107
ThreadFrame last_picture
Definition: ffv1.h:95
Public header for CRC hash function implementation.
av_cold int ff_ffv1_close(AVCodecContext *avctx)
Definition: ffv1.c:201
uint8_t count
Definition: ffv1.h:64
VlcState * vlc_state
Definition: ffv1.h:72
char * stats_out
pass1 encoding statistics output buffer
Definition: avcodec.h:1545
int slice_width
Definition: ffv1.h:132
av_cold int ff_ffv1_init_slices_state(FFV1Context *f)
Definition: ffv1.c:105
void ff_thread_release_buffer(AVCodecContext *avctx, ThreadFrame *f)
Wrapper around release_buffer() frame-for multithreaded codecs.
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:203
int context_count
Definition: ffv1.h:70
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:606
simple assert() macros that are a bit more flexible than ISO C assert().
int ff_ffv1_allocate_initial_states(FFV1Context *f)
Definition: ffv1.c:158
int ac
1=range coder <-> 0=golomb rice
Definition: ffv1.h:100
#define AC_RANGE_CUSTOM_TAB
Definition: ffv1.h:57
Definition: ffv1.h:60
uint8_t state_transition[256]
Definition: ffv1.h:106
int num_h_slices
Definition: ffv1.h:131
int width
picture width / height.
Definition: avcodec.h:699
#define MAX_PLANES
Definition: ffv1.h:49
int max_slice_count
Definition: ffv1.h:129
#define s(width, name)
Definition: cbs_vp9.c:257
av_cold int ff_ffv1_init_slice_contexts(FFV1Context *f)
Definition: ffv1.c:116
av_cold int ff_ffv1_init_slice_state(FFV1Context *f, FFV1Context *fs)
Definition: ffv1.c:66
int16_t drift
Definition: ffv1.h:61
int context_count[MAX_QUANT_TABLES]
Definition: ffv1.h:105
Libavcodec external API header.
main external API structure.
Definition: avcodec.h:526
#define AC_GOLOMB_RICE
Definition: ffv1.h:55
uint16_t error_sum
Definition: ffv1.h:62
int32_t * sample_buffer32
Definition: ffv1.h:111
#define CONTEXT_SIZE
Definition: ffv1.h:50
int quant_table_index
Definition: ffv1.h:69
common internal api header.
void ff_ffv1_clear_slice_state(FFV1Context *f, FFV1Context *fs)
Definition: ffv1.c:173
uint8_t(* state)[CONTEXT_SIZE]
Definition: ffv1.h:71
void * priv_data
Definition: avcodec.h:553
PlaneContext plane[MAX_PLANES]
Definition: ffv1.h:102
int transparency
Definition: ffv1.h:91
struct FFV1Context * slice_context[MAX_SLICES]
Definition: ffv1.h:127
uint8_t interlace_bit_state[2]
Definition: ffv1.h:73
#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:130
AVCodecContext * avctx
Definition: ffv1.h:80
int slice_x
Definition: ffv1.h:134
int i
Definition: input.c:407
int width
Definition: ffv1.h:88
void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.c:190