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();
52  s->last_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; i++) {
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  av_freep(&fs->sample_buffer);
149  av_freep(&fs->sample_buffer32);
150  av_freep(&f->slice_context[i]);
151  goto memfail;
152  }
153  }
154  f->max_slice_count = max_slice_count;
155  return 0;
156 
157 memfail:
158  while(--i >= 0) {
159  av_freep(&f->slice_context[i]->sample_buffer);
160  av_freep(&f->slice_context[i]->sample_buffer32);
161  av_freep(&f->slice_context[i]);
162  }
163  return AVERROR(ENOMEM);
164 }
165 
167 {
168  int i;
169 
170  for (i = 0; i < f->quant_table_count; i++) {
171  f->initial_states[i] = av_malloc_array(f->context_count[i],
172  sizeof(*f->initial_states[i]));
173  if (!f->initial_states[i])
174  return AVERROR(ENOMEM);
175  memset(f->initial_states[i], 128,
176  f->context_count[i] * sizeof(*f->initial_states[i]));
177  }
178  return 0;
179 }
180 
182 {
183  int i, j;
184 
185  for (i = 0; i < f->plane_count; i++) {
186  PlaneContext *p = &fs->plane[i];
187 
188  p->interlace_bit_state[0] = 128;
189  p->interlace_bit_state[1] = 128;
190 
191  if (fs->ac != AC_GOLOMB_RICE) {
192  if (f->initial_states[p->quant_table_index]) {
193  memcpy(p->state, f->initial_states[p->quant_table_index],
195  } else
196  memset(p->state, 128, CONTEXT_SIZE * p->context_count);
197  } else {
198  for (j = 0; j < p->context_count; j++) {
199  p->vlc_state[j].drift = 0;
200  p->vlc_state[j].error_sum = 4; //FFMAX((RANGE + 32)/64, 2);
201  p->vlc_state[j].bias = 0;
202  p->vlc_state[j].count = 1;
203  }
204  }
205  }
206 }
207 
208 
210 {
211  FFV1Context *s = avctx->priv_data;
212  int i, j;
213 
214  if (s->picture.f)
215  ff_thread_release_buffer(avctx, &s->picture);
216  av_frame_free(&s->picture.f);
217 
218  if (s->last_picture.f)
219  ff_thread_release_buffer(avctx, &s->last_picture);
220  av_frame_free(&s->last_picture.f);
221 
222  for (j = 0; j < s->max_slice_count; j++) {
223  FFV1Context *fs = s->slice_context[j];
224  for (i = 0; i < s->plane_count; i++) {
225  PlaneContext *p = &fs->plane[i];
226 
227  av_freep(&p->state);
228  av_freep(&p->vlc_state);
229  }
230  av_freep(&fs->sample_buffer);
231  av_freep(&fs->sample_buffer32);
232  }
233 
234  av_freep(&avctx->stats_out);
235  for (j = 0; j < s->quant_table_count; j++) {
236  av_freep(&s->initial_states[j]);
237  for (i = 0; i < s->max_slice_count; i++) {
238  FFV1Context *sf = s->slice_context[i];
239  av_freep(&sf->rc_stat2[j]);
240  }
241  av_freep(&s->rc_stat2[j]);
242  }
243 
244  for (i = 0; i < s->max_slice_count; i++)
245  av_freep(&s->slice_context[i]);
246 
247  return 0;
248 }
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
opt.h
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:203
pixdesc.h
ff_ffv1_common_init
av_cold int ff_ffv1_common_init(AVCodecContext *avctx)
Definition: ffv1.c:41
internal.h
rangecoder.h
PlaneContext::state
uint8_t(* state)[CONTEXT_SIZE]
Definition: ffv1.h:71
av_mallocz_array
void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.c:190
ff_ffv1_init_slice_state
av_cold int ff_ffv1_init_slice_state(FFV1Context *f, FFV1Context *fs)
Definition: ffv1.c:66
AC_RANGE_CUSTOM_TAB
#define AC_RANGE_CUSTOM_TAB
Definition: ffv1.h:57
crc.h
ff_ffv1_init_slices_state
av_cold int ff_ffv1_init_slices_state(FFV1Context *f)
Definition: ffv1.c:105
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:606
CONTEXT_SIZE
#define CONTEXT_SIZE
Definition: ffv1.h:50
PlaneContext::context_count
int context_count
Definition: ffv1.h:70
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:190
avassert.h
av_cold
#define av_cold
Definition: attributes.h:90
ff_ffv1_clear_slice_state
void ff_ffv1_clear_slice_state(FFV1Context *f, FFV1Context *fs)
Definition: ffv1.c:181
s
#define s(width, name)
Definition: cbs_vp9.c:257
MAX_PLANES
#define MAX_PLANES
Definition: ffv1.h:49
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:62
f
#define f(width, name)
Definition: cbs_vp9.c:255
PlaneContext::interlace_bit_state
uint8_t interlace_bit_state[2]
Definition: ffv1.h:73
PlaneContext::vlc_state
VlcState * vlc_state
Definition: ffv1.h:72
AC_GOLOMB_RICE
#define AC_GOLOMB_RICE
Definition: ffv1.h:55
fs
#define fs(width, name, subs,...)
Definition: cbs_vp9.c:259
mathops.h
PlaneContext
Definition: ffv1.h:67
VlcState
Definition: ffv1.h:60
ff_thread_release_buffer
void ff_thread_release_buffer(AVCodecContext *avctx, ThreadFrame *f)
Wrapper around release_buffer() frame-for multithreaded codecs.
Definition: pthread_frame.c:1006
AVCodecContext::stats_out
char * stats_out
pass1 encoding statistics output buffer
Definition: avcodec.h:1545
ff_ffv1_close
av_cold int ff_ffv1_close(AVCodecContext *avctx)
Definition: ffv1.c:209
VlcState::count
uint8_t count
Definition: ffv1.h:64
attributes.h
PlaneContext::quant_table_index
int quant_table_index
Definition: ffv1.h:69
VlcState::drift
int16_t drift
Definition: ffv1.h: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:32
ffv1.h
uint8_t
uint8_t
Definition: audio_convert.c:194
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:237
AVCodecContext::height
int height
Definition: avcodec.h:699
avcodec.h
ret
ret
Definition: filter_design.txt:187
FFV1Context::rc_stat2
uint64_t(*[MAX_QUANT_TABLES] rc_stat2)[32][2]
Definition: ffv1.h:85
ff_ffv1_allocate_initial_states
int ff_ffv1_allocate_initial_states(FFV1Context *f)
Definition: ffv1.c:166
AVCodecContext
main external API structure.
Definition: avcodec.h:526
VlcState::bias
int8_t bias
Definition: ffv1.h:63
FFV1Context
Definition: ffv1.h:78
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:553
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:699
ff_ffv1_init_slice_contexts
av_cold int ff_ffv1_init_slice_contexts(FFV1Context *f)
Definition: ffv1.c:116
imgutils.h
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59