FFmpeg  4.3.9
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 
116 int ff_need_new_slices(int width, int num_h_slices, int chroma_shift) {
117  int mpw = 1<<chroma_shift;
118  int i = width * (int64_t)(num_h_slices - 1) / num_h_slices;
119 
120  return width % mpw && (width - i) % mpw == 0;
121 }
122 
124 {
125  int i, max_slice_count = f->num_h_slices * f->num_v_slices;
126 
127  av_assert0(max_slice_count > 0);
128 
129  for (i = 0; i < max_slice_count; i++) {
130  int sx = i % f->num_h_slices;
131  int sy = i / f->num_h_slices;
132  int sxs = f->avctx->width * sx / f->num_h_slices;
133  int sxe = f->avctx->width * (sx + 1) / f->num_h_slices;
134  int sys = f->avctx->height * sy / f->num_v_slices;
135  int sye = f->avctx->height * (sy + 1) / f->num_v_slices;
136  FFV1Context *fs = av_mallocz(sizeof(*fs));
137 
138  if (!fs)
139  goto memfail;
140 
141  f->slice_context[i] = fs;
142  memcpy(fs, f, sizeof(*fs));
143  memset(fs->rc_stat2, 0, sizeof(fs->rc_stat2));
144 
145  fs->slice_width = sxe - sxs;
146  fs->slice_height = sye - sys;
147  fs->slice_x = sxs;
148  fs->slice_y = sys;
149 
150  fs->sample_buffer = av_malloc_array((fs->width + 6), 3 * MAX_PLANES *
151  sizeof(*fs->sample_buffer));
152  fs->sample_buffer32 = av_malloc_array((fs->width + 6), 3 * MAX_PLANES *
153  sizeof(*fs->sample_buffer32));
154  if (!fs->sample_buffer || !fs->sample_buffer32) {
155  av_freep(&fs->sample_buffer);
157  av_freep(&f->slice_context[i]);
158  goto memfail;
159  }
160  }
161  f->max_slice_count = max_slice_count;
162  return 0;
163 
164 memfail:
165  while(--i >= 0) {
168  av_freep(&f->slice_context[i]);
169  }
170  return AVERROR(ENOMEM);
171 }
172 
174 {
175  int i;
176 
177  for (i = 0; i < f->quant_table_count; i++) {
179  sizeof(*f->initial_states[i]));
180  if (!f->initial_states[i])
181  return AVERROR(ENOMEM);
182  memset(f->initial_states[i], 128,
183  f->context_count[i] * sizeof(*f->initial_states[i]));
184  }
185  return 0;
186 }
187 
189 {
190  int i, j;
191 
192  for (i = 0; i < f->plane_count; i++) {
193  PlaneContext *p = &fs->plane[i];
194 
195  p->interlace_bit_state[0] = 128;
196  p->interlace_bit_state[1] = 128;
197 
198  if (fs->ac != AC_GOLOMB_RICE) {
199  if (f->initial_states[p->quant_table_index]) {
200  memcpy(p->state, f->initial_states[p->quant_table_index],
202  } else
203  memset(p->state, 128, CONTEXT_SIZE * p->context_count);
204  } else {
205  for (j = 0; j < p->context_count; j++) {
206  p->vlc_state[j].drift = 0;
207  p->vlc_state[j].error_sum = 4; //FFMAX((RANGE + 32)/64, 2);
208  p->vlc_state[j].bias = 0;
209  p->vlc_state[j].count = 1;
210  }
211  }
212  }
213 }
214 
215 
217 {
218  FFV1Context *s = avctx->priv_data;
219  int i, j;
220 
221  if (s->picture.f)
222  ff_thread_release_buffer(avctx, &s->picture);
223  av_frame_free(&s->picture.f);
224 
225  if (s->last_picture.f)
228 
229  for (j = 0; j < s->max_slice_count; j++) {
230  FFV1Context *fs = s->slice_context[j];
231  for (i = 0; i < s->plane_count; i++) {
232  PlaneContext *p = &fs->plane[i];
233 
234  av_freep(&p->state);
235  av_freep(&p->vlc_state);
236  }
237  av_freep(&fs->sample_buffer);
239  }
240 
241  av_freep(&avctx->stats_out);
242  for (j = 0; j < s->quant_table_count; j++) {
243  av_freep(&s->initial_states[j]);
244  for (i = 0; i < s->max_slice_count; i++) {
245  FFV1Context *sf = s->slice_context[i];
246  av_freep(&sf->rc_stat2[j]);
247  }
248  av_freep(&s->rc_stat2[j]);
249  }
250 
251  for (i = 0; i < s->max_slice_count; i++)
252  av_freep(&s->slice_context[i]);
253 
254  return 0;
255 }
#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
int ff_need_new_slices(int width, int num_h_slices, int chroma_shift)
Definition: ffv1.c:116
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:216
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:1549
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:173
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
#define width
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:123
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
long long int64_t
Definition: coverity.c:34
#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:188
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