FFmpeg  4.4.5
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;) {
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++) {
163  f->initial_states[i] = av_malloc_array(f->context_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)
211  ff_thread_release_buffer(avctx, &s->last_picture);
212  av_frame_free(&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);
223  av_freep(&fs->sample_buffer32);
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 }
Macro definitions for various function/variable attributes.
#define av_cold
Definition: attributes.h:88
uint8_t
simple assert() macros that are a bit more flexible than ISO C assert().
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
Libavcodec external API header.
#define s(width, name)
Definition: cbs_vp9.c:257
#define f(width, name)
Definition: cbs_vp9.c:255
#define fs(width, name, subs,...)
Definition: cbs_vp9.c:259
Public header for CRC hash function implementation.
av_cold int ff_ffv1_common_init(AVCodecContext *avctx)
Definition: ffv1.c:41
av_cold int ff_ffv1_close(AVCodecContext *avctx)
Definition: ffv1.c:201
av_cold int ff_ffv1_init_slices_state(FFV1Context *f)
Definition: ffv1.c:105
int ff_ffv1_allocate_initial_states(FFV1Context *f)
Definition: ffv1.c:158
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
void ff_ffv1_clear_slice_state(FFV1Context *f, FFV1Context *fs)
Definition: ffv1.c:173
FF Video Codec 1 (a lossless codec)
#define CONTEXT_SIZE
Definition: ffv1.h:50
#define MAX_PLANES
Definition: ffv1.h:49
#define AC_GOLOMB_RICE
Definition: ffv1.h:55
#define AC_RANGE_CUSTOM_TAB
Definition: ffv1.h:57
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
#define AVERROR(e)
Definition: error.h:43
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:203
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:190
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
void * av_mallocz_array(size_t nmemb, size_t size)
Allocate a memory block for an array with av_mallocz().
Definition: mem.c:190
misc image utilities
int i
Definition: input.c:407
common internal API header
AVOptions.
void ff_thread_release_buffer(AVCodecContext *avctx, ThreadFrame *f)
Wrapper around release_buffer() frame-for multithreaded codecs.
Range coder.
main external API structure.
Definition: avcodec.h:536
int width
picture width / height.
Definition: avcodec.h:709
char * stats_out
pass1 encoding statistics output buffer
Definition: avcodec.h:1557
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:616
void * priv_data
Definition: avcodec.h:563
uint64_t(*[MAX_QUANT_TABLES] rc_stat2)[32][2]
Definition: ffv1.h:85
VlcState * vlc_state
Definition: ffv1.h:72
int quant_table_index
Definition: ffv1.h:69
uint8_t interlace_bit_state[2]
Definition: ffv1.h:73
int context_count
Definition: ffv1.h:70
uint8_t(* state)[CONTEXT_SIZE]
Definition: ffv1.h:71
Definition: ffv1.h:60
uint16_t error_sum
Definition: ffv1.h:62
int8_t bias
Definition: ffv1.h:63
uint8_t count
Definition: ffv1.h:64
int16_t drift
Definition: ffv1.h:61
#define av_malloc_array(a, b)
#define av_freep(p)