FFmpeg  4.4.6
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 
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;) {
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  goto memfail;
156  }
157  f->max_slice_count = max_slice_count;
158  return 0;
159 
160 memfail:
161  f->max_slice_count = i;
162  return AVERROR(ENOMEM);
163 }
164 
166 {
167  int i;
168 
169  for (i = 0; i < f->quant_table_count; i++) {
170  f->initial_states[i] = av_malloc_array(f->context_count[i],
171  sizeof(*f->initial_states[i]));
172  if (!f->initial_states[i])
173  return AVERROR(ENOMEM);
174  memset(f->initial_states[i], 128,
175  f->context_count[i] * sizeof(*f->initial_states[i]));
176  }
177  return 0;
178 }
179 
181 {
182  int i, j;
183 
184  for (i = 0; i < f->plane_count; i++) {
185  PlaneContext *p = &fs->plane[i];
186 
187  p->interlace_bit_state[0] = 128;
188  p->interlace_bit_state[1] = 128;
189 
190  if (fs->ac != AC_GOLOMB_RICE) {
191  if (f->initial_states[p->quant_table_index]) {
192  memcpy(p->state, f->initial_states[p->quant_table_index],
194  } else
195  memset(p->state, 128, CONTEXT_SIZE * p->context_count);
196  } else {
197  for (j = 0; j < p->context_count; j++) {
198  p->vlc_state[j].drift = 0;
199  p->vlc_state[j].error_sum = 4; //FFMAX((RANGE + 32)/64, 2);
200  p->vlc_state[j].bias = 0;
201  p->vlc_state[j].count = 1;
202  }
203  }
204  }
205 }
206 
207 
209 {
210  FFV1Context *s = avctx->priv_data;
211  int i, j;
212 
213  if (s->picture.f)
214  ff_thread_release_buffer(avctx, &s->picture);
215  av_frame_free(&s->picture.f);
216 
217  if (s->last_picture.f)
218  ff_thread_release_buffer(avctx, &s->last_picture);
219  av_frame_free(&s->last_picture.f);
220 
221  for (j = 0; j < s->max_slice_count; j++) {
222  FFV1Context *fs = s->slice_context[j];
223  for (i = 0; i < s->plane_count; i++) {
224  PlaneContext *p = &fs->plane[i];
225 
226  av_freep(&p->state);
227  av_freep(&p->vlc_state);
228  }
229  av_freep(&fs->sample_buffer);
230  av_freep(&fs->sample_buffer32);
231  }
232 
233  av_freep(&avctx->stats_out);
234  for (j = 0; j < s->quant_table_count; j++) {
235  av_freep(&s->initial_states[j]);
236  for (i = 0; i < s->max_slice_count; i++) {
237  FFV1Context *sf = s->slice_context[i];
238  av_freep(&sf->rc_stat2[j]);
239  }
240  av_freep(&s->rc_stat2[j]);
241  }
242 
243  for (i = 0; i < s->max_slice_count; i++)
244  av_freep(&s->slice_context[i]);
245 
246  return 0;
247 }
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
long long int64_t
Definition: coverity.c:34
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:208
av_cold int ff_ffv1_init_slices_state(FFV1Context *f)
Definition: ffv1.c:105
int ff_need_new_slices(int width, int num_h_slices, int chroma_shift)
Definition: ffv1.c:116
int ff_ffv1_allocate_initial_states(FFV1Context *f)
Definition: ffv1.c:165
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
void ff_ffv1_clear_slice_state(FFV1Context *f, FFV1Context *fs)
Definition: ffv1.c:180
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:1561
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)
#define width