FFmpeg  4.3.8
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; 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);
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) {
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++) {
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)
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);
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 }
#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.
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:209
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
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
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.
#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
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().
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
int ff_ffv1_allocate_initial_states(FFV1Context *f)
Definition: ffv1.c:166
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:181
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)
int num_v_slices
Definition: ffv1.h:130
AVCodecContext * avctx
Definition: ffv1.h:80
int slice_x
Definition: ffv1.h:134
int width
Definition: ffv1.h:88
void * av_mallocz_array(size_t nmemb, size_t size)
Allocate a memory block for an array with av_mallocz().
Definition: mem.c:190