FFmpeg  4.4.6
cfhdenc.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2020 Paul B Mahol
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 /**
22  * @file
23  * Cineform HD video encoder
24  */
25 
26 #include <stdlib.h>
27 #include <string.h>
28 
29 #include "libavutil/avassert.h"
30 #include "libavutil/imgutils.h"
31 #include "libavutil/opt.h"
32 
33 #include "avcodec.h"
34 #include "bytestream.h"
35 #include "cfhd.h"
36 #include "cfhdencdsp.h"
37 #include "put_bits.h"
38 #include "internal.h"
39 #include "thread.h"
40 
41 /* Derived from existing tables from decoder */
42 static const unsigned codebook[256][2] = {
43  { 1, 0x00000000 }, { 2, 0x00000002 }, { 3, 0x00000007 }, { 5, 0x00000019 }, { 6, 0x00000030 },
44  { 6, 0x00000036 }, { 7, 0x00000063 }, { 7, 0x0000006B }, { 7, 0x0000006F }, { 8, 0x000000D4 },
45  { 8, 0x000000DC }, { 9, 0x00000189 }, { 9, 0x000001A0 }, { 9, 0x000001AB }, {10, 0x00000310 },
46  {10, 0x00000316 }, {10, 0x00000354 }, {10, 0x00000375 }, {10, 0x00000377 }, {11, 0x00000623 },
47  {11, 0x00000684 }, {11, 0x000006AB }, {11, 0x000006EC }, {12, 0x00000C44 }, {12, 0x00000C5C },
48  {12, 0x00000C5E }, {12, 0x00000D55 }, {12, 0x00000DD1 }, {12, 0x00000DD3 }, {12, 0x00000DDB },
49  {13, 0x0000188B }, {13, 0x000018BB }, {13, 0x00001AA8 }, {13, 0x00001BA0 }, {13, 0x00001BA4 },
50  {13, 0x00001BB5 }, {14, 0x00003115 }, {14, 0x00003175 }, {14, 0x0000317D }, {14, 0x00003553 },
51  {14, 0x00003768 }, {15, 0x00006228 }, {15, 0x000062E8 }, {15, 0x000062F8 }, {15, 0x00006AA4 },
52  {15, 0x00006E85 }, {15, 0x00006E87 }, {15, 0x00006ED3 }, {16, 0x0000C453 }, {16, 0x0000C5D3 },
53  {16, 0x0000C5F3 }, {16, 0x0000DD08 }, {16, 0x0000DD0C }, {16, 0x0000DDA4 }, {17, 0x000188A4 },
54  {17, 0x00018BA5 }, {17, 0x00018BE5 }, {17, 0x0001AA95 }, {17, 0x0001AA97 }, {17, 0x0001BA13 },
55  {17, 0x0001BB4A }, {17, 0x0001BB4B }, {18, 0x00031748 }, {18, 0x000317C8 }, {18, 0x00035528 },
56  {18, 0x0003552C }, {18, 0x00037424 }, {18, 0x00037434 }, {18, 0x00037436 }, {19, 0x00062294 },
57  {19, 0x00062E92 }, {19, 0x00062F92 }, {19, 0x0006AA52 }, {19, 0x0006AA5A }, {19, 0x0006E84A },
58  {19, 0x0006E86A }, {19, 0x0006E86E }, {20, 0x000C452A }, {20, 0x000C5D27 }, {20, 0x000C5F26 },
59  {20, 0x000D54A6 }, {20, 0x000D54B6 }, {20, 0x000DD096 }, {20, 0x000DD0D6 }, {20, 0x000DD0DE },
60  {21, 0x00188A56 }, {21, 0x0018BA4D }, {21, 0x0018BE4E }, {21, 0x0018BE4F }, {21, 0x001AA96E },
61  {21, 0x001BA12E }, {21, 0x001BA12F }, {21, 0x001BA1AF }, {21, 0x001BA1BF }, {22, 0x00317498 },
62  {22, 0x0035529C }, {22, 0x0035529D }, {22, 0x003552DE }, {22, 0x003552DF }, {22, 0x0037435D },
63  {22, 0x0037437D }, {23, 0x0062295D }, {23, 0x0062E933 }, {23, 0x006AA53D }, {23, 0x006AA53E },
64  {23, 0x006AA53F }, {23, 0x006E86B9 }, {23, 0x006E86F8 }, {24, 0x00C452B8 }, {24, 0x00C5D265 },
65  {24, 0x00D54A78 }, {24, 0x00D54A79 }, {24, 0x00DD0D70 }, {24, 0x00DD0D71 }, {24, 0x00DD0DF2 },
66  {24, 0x00DD0DF3 }, {26, 0x03114BA2 }, {25, 0x0188A5B1 }, {25, 0x0188A58B }, {25, 0x0188A595 },
67  {25, 0x0188A5D6 }, {25, 0x0188A5D7 }, {25, 0x0188A5A8 }, {25, 0x0188A5AE }, {25, 0x0188A5AF },
68  {25, 0x0188A5C4 }, {25, 0x0188A5C5 }, {25, 0x0188A587 }, {25, 0x0188A584 }, {25, 0x0188A585 },
69  {25, 0x0188A5C6 }, {25, 0x0188A5C7 }, {25, 0x0188A5CC }, {25, 0x0188A5CD }, {25, 0x0188A581 },
70  {25, 0x0188A582 }, {25, 0x0188A583 }, {25, 0x0188A5CE }, {25, 0x0188A5CF }, {25, 0x0188A5C2 },
71  {25, 0x0188A5C3 }, {25, 0x0188A5C1 }, {25, 0x0188A5B4 }, {25, 0x0188A5B5 }, {25, 0x0188A5E6 },
72  {25, 0x0188A5E7 }, {25, 0x0188A5E4 }, {25, 0x0188A5E5 }, {25, 0x0188A5AB }, {25, 0x0188A5E0 },
73  {25, 0x0188A5E1 }, {25, 0x0188A5E2 }, {25, 0x0188A5E3 }, {25, 0x0188A5B6 }, {25, 0x0188A5B7 },
74  {25, 0x0188A5FD }, {25, 0x0188A57E }, {25, 0x0188A57F }, {25, 0x0188A5EC }, {25, 0x0188A5ED },
75  {25, 0x0188A5FE }, {25, 0x0188A5FF }, {25, 0x0188A57D }, {25, 0x0188A59C }, {25, 0x0188A59D },
76  {25, 0x0188A5E8 }, {25, 0x0188A5E9 }, {25, 0x0188A5EA }, {25, 0x0188A5EB }, {25, 0x0188A5EF },
77  {25, 0x0188A57A }, {25, 0x0188A57B }, {25, 0x0188A578 }, {25, 0x0188A579 }, {25, 0x0188A5BA },
78  {25, 0x0188A5BB }, {25, 0x0188A5B8 }, {25, 0x0188A5B9 }, {25, 0x0188A588 }, {25, 0x0188A589 },
79  {25, 0x018BA4C8 }, {25, 0x018BA4C9 }, {25, 0x0188A5FA }, {25, 0x0188A5FB }, {25, 0x0188A5BC },
80  {25, 0x0188A5BD }, {25, 0x0188A598 }, {25, 0x0188A599 }, {25, 0x0188A5F4 }, {25, 0x0188A5F5 },
81  {25, 0x0188A59B }, {25, 0x0188A5DE }, {25, 0x0188A5DF }, {25, 0x0188A596 }, {25, 0x0188A597 },
82  {25, 0x0188A5F8 }, {25, 0x0188A5F9 }, {25, 0x0188A5F1 }, {25, 0x0188A58E }, {25, 0x0188A58F },
83  {25, 0x0188A5DC }, {25, 0x0188A5DD }, {25, 0x0188A5F2 }, {25, 0x0188A5F3 }, {25, 0x0188A58C },
84  {25, 0x0188A58D }, {25, 0x0188A5A4 }, {25, 0x0188A5F0 }, {25, 0x0188A5A5 }, {25, 0x0188A5A6 },
85  {25, 0x0188A5A7 }, {25, 0x0188A59A }, {25, 0x0188A5A2 }, {25, 0x0188A5A3 }, {25, 0x0188A58A },
86  {25, 0x0188A5B0 }, {25, 0x0188A5A0 }, {25, 0x0188A5A1 }, {25, 0x0188A5DA }, {25, 0x0188A5DB },
87  {25, 0x0188A59E }, {25, 0x0188A59F }, {25, 0x0188A5D8 }, {25, 0x0188A5EE }, {25, 0x0188A5D9 },
88  {25, 0x0188A5F6 }, {25, 0x0188A5F7 }, {25, 0x0188A57C }, {25, 0x0188A5C8 }, {25, 0x0188A5C9 },
89  {25, 0x0188A594 }, {25, 0x0188A5FC }, {25, 0x0188A5CA }, {25, 0x0188A5CB }, {25, 0x0188A5B2 },
90  {25, 0x0188A5AA }, {25, 0x0188A5B3 }, {25, 0x0188A572 }, {25, 0x0188A573 }, {25, 0x0188A5C0 },
91  {25, 0x0188A5BE }, {25, 0x0188A5BF }, {25, 0x0188A592 }, {25, 0x0188A580 }, {25, 0x0188A593 },
92  {25, 0x0188A590 }, {25, 0x0188A591 }, {25, 0x0188A586 }, {25, 0x0188A5A9 }, {25, 0x0188A5D2 },
93  {25, 0x0188A5D3 }, {25, 0x0188A5D4 }, {25, 0x0188A5D5 }, {25, 0x0188A5AC }, {25, 0x0188A5AD },
94  {25, 0x0188A5D0 },
95 };
96 
97 /* Derived by extracting runcodes from existing tables from decoder */
98 static const uint16_t runbook[18][3] = {
99  {1, 0x0000, 1}, {2, 0x0000, 2}, {3, 0x0000, 3}, {4, 0x0000, 4},
100  {5, 0x0000, 5}, {6, 0x0000, 6}, {7, 0x0000, 7}, {8, 0x0000, 8},
101  {9, 0x0000, 9}, {10, 0x0000, 10}, {11, 0x0000, 11},
102  {7, 0x0069, 12}, {8, 0x00D1, 20}, {9, 0x018A, 32},
103  {10, 0x0343, 60}, {11, 0x0685, 100}, {13, 0x18BF, 180}, {13, 0x1BA5, 320},
104 };
105 
106 /*
107  * Derived by inspecting various quality encodes
108  * and adding some more from scratch.
109  */
110 static const uint16_t quantization_per_subband[2][3][13][9] = {
111  {{
112  { 16, 16, 8, 4, 4, 2, 6, 6, 9, }, // film3+
113  { 16, 16, 8, 4, 4, 2, 6, 6, 9, }, // film3
114  { 16, 16, 8, 4, 4, 2, 7, 7, 10, }, // film2+
115  { 16, 16, 8, 4, 4, 2, 8, 8, 12, }, // film2
116  { 16, 16, 8, 4, 4, 2, 16, 16, 26, }, // film1++
117  { 24, 24, 12, 6, 6, 3, 24, 24, 36, }, // film1+
118  { 24, 24, 12, 6, 6, 3, 24, 24, 36, }, // film1
119  { 32, 32, 24, 8, 8, 6, 32, 32, 48, }, // high+
120  { 32, 32, 24, 8, 8, 6, 32, 32, 48, }, // high
121  { 48, 48, 32, 12, 12, 8, 64, 64, 96, }, // medium+
122  { 48, 48, 32, 12, 12, 8, 64, 64, 96, }, // medium
123  { 64, 64, 48, 16, 16, 12, 96, 96, 144, }, // low+
124  { 64, 64, 48, 16, 16, 12, 128, 128, 192, }, // low
125  },
126  {
127  { 16, 16, 8, 4, 4, 2, 6, 6, 9, }, // film3+
128  { 16, 16, 8, 4, 4, 2, 6, 6, 12, }, // film3
129  { 16, 16, 8, 4, 4, 2, 7, 7, 14, }, // film2+
130  { 16, 16, 8, 4, 4, 2, 8, 8, 16, }, // film2
131  { 16, 16, 8, 4, 4, 2, 16, 16, 26, }, // film1++
132  { 24, 24, 12, 6, 6, 3, 24, 24, 36, }, // film1+
133  { 24, 24, 12, 6, 6, 3, 24, 24, 48, }, // film1
134  { 32, 32, 24, 8, 8, 6, 32, 32, 48, }, // high+
135  { 48, 48, 32, 12, 12, 8, 32, 32, 64, }, // high
136  { 48, 48, 32, 12, 12, 8, 64, 64, 96, }, // medium+
137  { 48, 48, 32, 12, 12, 8, 64, 64, 128, }, // medium
138  { 64, 64, 48, 16, 16, 12, 96, 96, 160, }, // low+
139  { 64, 64, 48, 16, 16, 12, 128, 128, 192, }, // low
140  },
141  {
142  { 16, 16, 8, 4, 4, 2, 6, 6, 9, }, // film3+
143  { 16, 16, 8, 4, 4, 2, 6, 6, 12, }, // film3
144  { 16, 16, 8, 4, 4, 2, 7, 7, 14, }, // film2+
145  { 16, 16, 8, 4, 4, 2, 8, 8, 16, }, // film2
146  { 16, 16, 8, 4, 4, 2, 16, 16, 26, }, // film1++
147  { 24, 24, 12, 6, 6, 3, 24, 24, 36, }, // film1+
148  { 24, 24, 12, 6, 6, 3, 24, 24, 48, }, // film1
149  { 32, 32, 24, 8, 8, 6, 32, 32, 48, }, // high+
150  { 48, 48, 32, 12, 12, 8, 32, 32, 64, }, // high
151  { 48, 48, 32, 12, 12, 8, 64, 64, 96, }, // medium+
152  { 48, 48, 32, 12, 12, 8, 64, 64, 128, }, // medium
153  { 64, 64, 48, 16, 16, 12, 96, 96, 160, }, // low+
154  { 64, 64, 48, 16, 16, 12, 128, 128, 192, }, // low
155  }},
156  {{
157  { 16, 16, 8, 16, 16, 8, 24, 24, 36, }, // film3+
158  { 16, 16, 8, 16, 16, 8, 24, 24, 36, }, // film3
159  { 16, 16, 8, 16, 16, 8, 32, 32, 48, }, // film2+
160  { 16, 16, 8, 16, 16, 8, 32, 32, 48, }, // film2
161  { 16, 16, 8, 20, 20, 10, 80, 80, 128, }, // film1++
162  { 24, 24, 12, 24, 24, 12, 96, 96, 144, }, // film1+
163  { 24, 24, 12, 24, 24, 12, 96, 96, 144, }, // film1
164  { 32, 32, 24, 32, 32, 24, 128, 128, 192, }, // high+
165  { 32, 32, 24, 32, 32, 24, 128, 128, 192, }, // high
166  { 48, 48, 32, 48, 48, 32, 256, 256, 384, }, // medium+
167  { 48, 48, 32, 48, 48, 32, 256, 256, 384, }, // medium
168  { 56, 56, 40, 56, 56, 40, 512, 512, 768, }, // low+
169  { 64, 64, 48, 64, 64, 48, 512, 512, 768, }, // low
170  },
171  {
172  { 16, 16, 8, 16, 16, 8, 24, 24, 36, }, // film3+
173  { 16, 16, 8, 16, 16, 8, 48, 48, 72, }, // film3
174  { 16, 16, 8, 16, 16, 8, 48, 48, 72, }, // film2+
175  { 16, 16, 8, 16, 16, 8, 64, 64, 96, }, // film2
176  { 16, 16, 8, 20, 20, 10, 80, 80, 128, }, // film1++
177  { 24, 24, 12, 24, 24, 12, 96, 96, 144, }, // film1+
178  { 24, 24, 12, 24, 24, 12, 192, 192, 288, }, // film1
179  { 32, 32, 24, 32, 32, 24, 128, 128, 192, }, // high+
180  { 32, 32, 24, 32, 32, 24, 256, 256, 384, }, // high
181  { 48, 48, 32, 48, 48, 32, 256, 256, 384, }, // medium+
182  { 48, 48, 32, 48, 48, 32, 512, 512, 768, }, // medium
183  { 56, 56, 40, 56, 56, 40, 512, 512, 768, }, // low+
184  { 64, 64, 48, 64, 64, 48,1024,1024,1536, }, // low
185  },
186  {
187  { 16, 16, 8, 16, 16, 8, 24, 24, 36, }, // film3+
188  { 16, 16, 8, 16, 16, 8, 48, 48, 72, }, // film3
189  { 16, 16, 8, 16, 16, 8, 48, 48, 72, }, // film2+
190  { 16, 16, 8, 16, 16, 8, 64, 64, 96, }, // film2
191  { 16, 16, 10, 20, 20, 10, 80, 80, 128, }, // film1++
192  { 24, 24, 12, 24, 24, 12, 96, 96, 144, }, // film1+
193  { 24, 24, 12, 24, 24, 12, 192, 192, 288, }, // film1
194  { 32, 32, 24, 32, 32, 24, 128, 128, 192, }, // high+
195  { 32, 32, 24, 32, 32, 24, 256, 256, 384, }, // high
196  { 48, 48, 32, 48, 48, 32, 256, 256, 384, }, // medium+
197  { 48, 48, 32, 48, 48, 32, 512, 512, 768, }, // medium
198  { 56, 56, 40, 56, 56, 40, 512, 512, 768, }, // low+
199  { 64, 64, 48, 64, 64, 48,1024,1024,1536, }, // low
200  }},
201 };
202 
203 typedef struct Codebook {
204  unsigned bits;
205  unsigned size;
206 } Codebook;
207 
208 typedef struct Runbook {
209  unsigned size;
210  unsigned bits;
211  unsigned run;
212 } Runbook;
213 
214 typedef struct PlaneEnc {
215  unsigned size;
216 
217  int16_t *dwt_buf;
218  int16_t *dwt_tmp;
219 
222  int16_t *l_h[8];
223 
225 } PlaneEnc;
226 
227 typedef struct CFHDEncContext {
228  const AVClass *class;
229 
232 
233  int quality;
234  int planes;
238 
239  uint16_t lut[1024];
240  Runbook rb[321];
241  Codebook cb[513];
242  int16_t *alpha;
243 
246 
248 {
249  CFHDEncContext *s = avctx->priv_data;
250  const int sign_mask = 256;
251  const int twos_complement = -sign_mask;
252  const int mag_mask = sign_mask - 1;
253  int ret, last = 0;
254 
256  &s->chroma_h_shift,
257  &s->chroma_v_shift);
258  if (ret < 0)
259  return ret;
260 
261  if (avctx->height < 32) {
262  av_log(avctx, AV_LOG_ERROR, "Height must be >= 32.\n");
263  return AVERROR_INVALIDDATA;
264  }
265 
266  if (avctx->width & 15) {
267  av_log(avctx, AV_LOG_ERROR, "Width must be multiple of 16.\n");
268  return AVERROR_INVALIDDATA;
269  }
270 
271  s->planes = av_pix_fmt_count_planes(avctx->pix_fmt);
272 
273  for (int i = 0; i < s->planes; i++) {
274  int w8, h8, w4, h4, w2, h2;
275  int width = i ? avctx->width >> s->chroma_h_shift : avctx->width;
276  int height = i ? FFALIGN(avctx->height >> s->chroma_v_shift, 8) :
277  FFALIGN(avctx->height >> s->chroma_v_shift, 8);
278  ptrdiff_t stride = (FFALIGN(width / 8, 8) + 64) * 8;
279 
280  w8 = FFALIGN(width / 8, 8) + 64;
281  h8 = FFALIGN(height, 8) / 8;
282  w4 = w8 * 2;
283  h4 = h8 * 2;
284  w2 = w4 * 2;
285  h2 = h4 * 2;
286 
287  s->plane[i].dwt_buf =
288  av_mallocz_array(height * stride, sizeof(*s->plane[i].dwt_buf));
289  s->plane[i].dwt_tmp =
290  av_malloc_array(height * stride, sizeof(*s->plane[i].dwt_tmp));
291  if (!s->plane[i].dwt_buf || !s->plane[i].dwt_tmp)
292  return AVERROR(ENOMEM);
293 
294  s->plane[i].subband[0] = s->plane[i].dwt_buf;
295  s->plane[i].subband[1] = s->plane[i].dwt_buf + 2 * w8 * h8;
296  s->plane[i].subband[2] = s->plane[i].dwt_buf + 1 * w8 * h8;
297  s->plane[i].subband[3] = s->plane[i].dwt_buf + 3 * w8 * h8;
298  s->plane[i].subband[4] = s->plane[i].dwt_buf + 2 * w4 * h4;
299  s->plane[i].subband[5] = s->plane[i].dwt_buf + 1 * w4 * h4;
300  s->plane[i].subband[6] = s->plane[i].dwt_buf + 3 * w4 * h4;
301  s->plane[i].subband[7] = s->plane[i].dwt_buf + 2 * w2 * h2;
302  s->plane[i].subband[8] = s->plane[i].dwt_buf + 1 * w2 * h2;
303  s->plane[i].subband[9] = s->plane[i].dwt_buf + 3 * w2 * h2;
304 
305  for (int j = 0; j < DWT_LEVELS; j++) {
306  for (int k = 0; k < FF_ARRAY_ELEMS(s->plane[i].band[j]); k++) {
307  s->plane[i].band[j][k].width = (width / 8) << j;
308  s->plane[i].band[j][k].height = (height / 8) << j;
309  s->plane[i].band[j][k].a_width = w8 << j;
310  s->plane[i].band[j][k].a_height = h8 << j;
311  }
312  }
313 
314  /* ll2 and ll1 commented out because they are done in-place */
315  s->plane[i].l_h[0] = s->plane[i].dwt_tmp;
316  s->plane[i].l_h[1] = s->plane[i].dwt_tmp + 2 * w8 * h8;
317  // s->plane[i].l_h[2] = ll2;
318  s->plane[i].l_h[3] = s->plane[i].dwt_tmp;
319  s->plane[i].l_h[4] = s->plane[i].dwt_tmp + 2 * w4 * h4;
320  // s->plane[i].l_h[5] = ll1;
321  s->plane[i].l_h[6] = s->plane[i].dwt_tmp;
322  s->plane[i].l_h[7] = s->plane[i].dwt_tmp + 2 * w2 * h2;
323  }
324 
325  for (int i = 0; i < 512; i++) {
326  int value = (i & sign_mask) ? twos_complement + (i & mag_mask): i;
327  int mag = FFMIN(FFABS(value), 255);
328 
329  if (mag) {
330  s->cb[i].bits = (codebook[mag][1] << 1) | (value > 0 ? 0 : 1);
331  s->cb[i].size = codebook[mag][0] + 1;
332  } else {
333  s->cb[i].bits = codebook[mag][1];
334  s->cb[i].size = codebook[mag][0];
335  }
336  }
337 
338  s->cb[512].bits = 0x3114ba3;
339  s->cb[512].size = 26;
340 
341  s->rb[0].run = 0;
342 
343  for (int i = 1, j = 0; i < 320 && j < 17; j++) {
344  int run = runbook[j][2];
345  int end = runbook[j+1][2];
346 
347  while (i < end) {
348  s->rb[i].run = run;
349  s->rb[i].bits = runbook[j][1];
350  s->rb[i++].size = runbook[j][0];
351  }
352  }
353 
354  s->rb[320].bits = runbook[17][1];
355  s->rb[320].size = runbook[17][0];
356  s->rb[320].run = 320;
357 
358  for (int i = 0; i < 256; i++) {
359  int idx = i + ((768LL * i * i * i) / (256 * 256 * 256));
360 
361  s->lut[idx] = i;
362  }
363  for (int i = 0; i < 1024; i++) {
364  if (s->lut[i])
365  last = s->lut[i];
366  else
367  s->lut[i] = last;
368  }
369 
370  ff_cfhdencdsp_init(&s->dsp);
371 
372  if (s->planes != 4)
373  return 0;
374 
375  s->alpha = av_calloc(avctx->width * avctx->height, sizeof(*s->alpha));
376  if (!s->alpha)
377  return AVERROR(ENOMEM);
378 
379  return 0;
380 }
381 
382 static void quantize_band(int16_t *input, int width, int a_width,
383  int height, unsigned quantization)
384 {
385  const int16_t factor = (uint32_t)(1U << 15) / quantization;
386 
387  for (int i = 0; i < height; i++) {
388  for (int j = 0; j < width; j++)
389  input[j] = av_clip_intp2(((input[j] * factor + 16384 * FFSIGN(input[j])) / 32768), 10);
390  input += a_width;
391  }
392 }
393 
394 static int put_runcode(PutBitContext *pb, int count, const Runbook *const rb)
395 {
396  while (count > 0) {
397  const int index = FFMIN(320, count);
398 
399  put_bits(pb, rb[index].size, rb[index].bits);
400  count -= rb[index].run;
401  }
402 
403  return 0;
404 }
405 
406 static void process_alpha(const int16_t *src, int width, int height, ptrdiff_t stride, int16_t *dst)
407 {
408  for (int i = 0; i < height; i++) {
409  for (int j = 0; j < width; j++) {
410  int alpha = src[j];
411 
412  if (alpha > 0 && alpha < 4080) {
413  alpha *= 223;
414  alpha += 128;
415  alpha >>= 8;
416  alpha += 256;
417  }
418 
419  dst[j] = av_clip_uintp2(alpha, 12);
420  }
421 
422  src += stride;
423  dst += width;
424  }
425 }
426 
428  const AVFrame *frame, int *got_packet)
429 {
430  CFHDEncContext *s = avctx->priv_data;
431  CFHDEncDSPContext *dsp = &s->dsp;
432  PutByteContext *pby = &s->pby;
433  PutBitContext *pb = &s->pb;
434  const Codebook *const cb = s->cb;
435  const Runbook *const rb = s->rb;
436  const uint16_t *lut = s->lut;
437  unsigned pos;
438  int ret;
439 
440  for (int plane = 0; plane < s->planes; plane++) {
441  int width = s->plane[plane].band[2][0].width;
442  int a_width = s->plane[plane].band[2][0].a_width;
443  int height = s->plane[plane].band[2][0].height;
444  int act_plane = plane == 1 ? 2 : plane == 2 ? 1 : plane;
445  int16_t *input = (int16_t *)frame->data[act_plane];
446  int16_t *low = s->plane[plane].l_h[6];
447  int16_t *high = s->plane[plane].l_h[7];
448  ptrdiff_t in_stride = frame->linesize[act_plane] / 2;
449  int low_stride, high_stride;
450 
451  if (plane == 3) {
452  process_alpha(input, avctx->width, avctx->height,
453  in_stride, s->alpha);
454  input = s->alpha;
455  in_stride = avctx->width;
456  }
457 
458  dsp->horiz_filter(input, low, high,
459  in_stride, a_width, a_width,
460  width * 2, height * 2);
461 
462  input = s->plane[plane].l_h[7];
463  low = s->plane[plane].subband[7];
464  low_stride = s->plane[plane].band[2][0].a_width;
465  high = s->plane[plane].subband[9];
466  high_stride = s->plane[plane].band[2][0].a_width;
467 
468  dsp->vert_filter(input, low, high,
469  a_width, low_stride, high_stride,
470  width, height * 2);
471 
472  input = s->plane[plane].l_h[6];
473  low = s->plane[plane].l_h[7];
474  high = s->plane[plane].subband[8];
475 
476  dsp->vert_filter(input, low, high,
477  a_width, low_stride, high_stride,
478  width, height * 2);
479 
480  a_width = s->plane[plane].band[1][0].a_width;
481  width = s->plane[plane].band[1][0].width;
482  height = s->plane[plane].band[1][0].height;
483  input = s->plane[plane].l_h[7];
484  low = s->plane[plane].l_h[3];
485  low_stride = s->plane[plane].band[1][0].a_width;
486  high = s->plane[plane].l_h[4];
487  high_stride = s->plane[plane].band[1][0].a_width;
488 
489  for (int i = 0; i < height * 2; i++) {
490  for (int j = 0; j < width * 2; j++)
491  input[j] /= 4;
492  input += a_width * 2;
493  }
494 
495  input = s->plane[plane].l_h[7];
496  dsp->horiz_filter(input, low, high,
497  a_width * 2, low_stride, high_stride,
498  width * 2, height * 2);
499 
500  input = s->plane[plane].l_h[4];
501  low = s->plane[plane].subband[4];
502  high = s->plane[plane].subband[6];
503 
504  dsp->vert_filter(input, low, high,
505  a_width, low_stride, high_stride,
506  width, height * 2);
507 
508  input = s->plane[plane].l_h[3];
509  low = s->plane[plane].l_h[4];
510  high = s->plane[plane].subband[5];
511 
512  dsp->vert_filter(input, low, high,
513  a_width, low_stride, high_stride,
514  width, height * 2);
515 
516  a_width = s->plane[plane].band[0][0].a_width;
517  width = s->plane[plane].band[0][0].width;
518  height = s->plane[plane].band[0][0].height;
519  input = s->plane[plane].l_h[4];
520  low = s->plane[plane].l_h[0];
521  low_stride = s->plane[plane].band[0][0].a_width;
522  high = s->plane[plane].l_h[1];
523  high_stride = s->plane[plane].band[0][0].a_width;
524 
525  if (avctx->pix_fmt != AV_PIX_FMT_YUV422P10) {
526  for (int i = 0; i < height * 2; i++) {
527  for (int j = 0; j < width * 2; j++)
528  input[j] /= 4;
529  input += a_width * 2;
530  }
531  }
532 
533  input = s->plane[plane].l_h[4];
534  dsp->horiz_filter(input, low, high,
535  a_width * 2, low_stride, high_stride,
536  width * 2, height * 2);
537 
538  low = s->plane[plane].subband[1];
539  high = s->plane[plane].subband[3];
540  input = s->plane[plane].l_h[1];
541 
542  dsp->vert_filter(input, low, high,
543  a_width, low_stride, high_stride,
544  width, height * 2);
545 
546  low = s->plane[plane].subband[0];
547  high = s->plane[plane].subband[2];
548  input = s->plane[plane].l_h[0];
549 
550  dsp->vert_filter(input, low, high,
551  a_width, low_stride, high_stride,
552  width, height * 2);
553  }
554 
555  ret = ff_alloc_packet2(avctx, pkt, 256LL + s->planes * (4LL * avctx->width * (avctx->height + 15) + 2048LL), 0);
556  if (ret < 0)
557  return ret;
558 
560 
561  bytestream2_put_be16(pby, SampleType);
562  bytestream2_put_be16(pby, 9);
563 
564  bytestream2_put_be16(pby, SampleIndexTable);
565  bytestream2_put_be16(pby, s->planes);
566 
567  for (int i = 0; i < s->planes; i++)
568  bytestream2_put_be32(pby, 0);
569 
570  bytestream2_put_be16(pby, TransformType);
571  bytestream2_put_be16(pby, 0);
572 
573  bytestream2_put_be16(pby, NumFrames);
574  bytestream2_put_be16(pby, 1);
575 
576  bytestream2_put_be16(pby, ChannelCount);
577  bytestream2_put_be16(pby, s->planes);
578 
579  bytestream2_put_be16(pby, EncodedFormat);
580  bytestream2_put_be16(pby, avctx->pix_fmt == AV_PIX_FMT_YUV422P10 ? 1 : 3 + (s->planes == 4));
581 
582  bytestream2_put_be16(pby, WaveletCount);
583  bytestream2_put_be16(pby, 3);
584 
585  bytestream2_put_be16(pby, SubbandCount);
586  bytestream2_put_be16(pby, SUBBAND_COUNT);
587 
588  bytestream2_put_be16(pby, NumSpatial);
589  bytestream2_put_be16(pby, 2);
590 
591  bytestream2_put_be16(pby, FirstWavelet);
592  bytestream2_put_be16(pby, 3);
593 
594  bytestream2_put_be16(pby, ImageWidth);
595  bytestream2_put_be16(pby, avctx->width);
596 
597  bytestream2_put_be16(pby, ImageHeight);
598  bytestream2_put_be16(pby, avctx->height);
599 
600  bytestream2_put_be16(pby, -FrameNumber);
601  bytestream2_put_be16(pby, frame->pts & 0xFFFF);
602 
603  bytestream2_put_be16(pby, Precision);
604  bytestream2_put_be16(pby, avctx->pix_fmt == AV_PIX_FMT_YUV422P10 ? 10 : 12);
605 
606  bytestream2_put_be16(pby, PrescaleTable);
607  bytestream2_put_be16(pby, avctx->pix_fmt == AV_PIX_FMT_YUV422P10 ? 0x2000 : 0x2800);
608 
609  bytestream2_put_be16(pby, SampleFlags);
610  bytestream2_put_be16(pby, 1);
611 
612  for (int p = 0; p < s->planes; p++) {
613  int width = s->plane[p].band[0][0].width;
614  int a_width = s->plane[p].band[0][0].a_width;
615  int height = s->plane[p].band[0][0].height;
616  int16_t *data = s->plane[p].subband[0];
617 
618  if (p) {
619  bytestream2_put_be16(pby, SampleType);
620  bytestream2_put_be16(pby, 3);
621 
622  bytestream2_put_be16(pby, ChannelNumber);
623  bytestream2_put_be16(pby, p);
624  }
625 
626  bytestream2_put_be16(pby, BitstreamMarker);
627  bytestream2_put_be16(pby, 0x1a4a);
628 
629  pos = bytestream2_tell_p(pby);
630 
631  bytestream2_put_be16(pby, LowpassSubband);
632  bytestream2_put_be16(pby, 0);
633 
634  bytestream2_put_be16(pby, NumLevels);
635  bytestream2_put_be16(pby, 3);
636 
637  bytestream2_put_be16(pby, LowpassWidth);
638  bytestream2_put_be16(pby, width);
639 
640  bytestream2_put_be16(pby, LowpassHeight);
641  bytestream2_put_be16(pby, height);
642 
643  bytestream2_put_be16(pby, PixelOffset);
644  bytestream2_put_be16(pby, 0);
645 
646  bytestream2_put_be16(pby, LowpassQuantization);
647  bytestream2_put_be16(pby, 1);
648 
649  bytestream2_put_be16(pby, LowpassPrecision);
650  bytestream2_put_be16(pby, 16);
651 
652  bytestream2_put_be16(pby, BitstreamMarker);
653  bytestream2_put_be16(pby, 0x0f0f);
654 
655  for (int i = 0; i < height; i++) {
656  for (int j = 0; j < width; j++)
657  bytestream2_put_be16(pby, data[j]);
658  data += a_width;
659  }
660 
661  bytestream2_put_be16(pby, BitstreamMarker);
662  bytestream2_put_be16(pby, 0x1b4b);
663 
664  for (int l = 0; l < 3; l++) {
665  for (int i = 0; i < 3; i++) {
666  s->plane[p].quantization[1 + l * 3 + i] = quantization_per_subband[avctx->pix_fmt != AV_PIX_FMT_YUV422P10][p >= 3 ? 0 : p][s->quality][l * 3 + i];
667  }
668  }
669 
670  for (int l = 0; l < 3; l++) {
671  int a_width = s->plane[p].band[l][0].a_width;
672  int width = s->plane[p].band[l][0].width;
673  int stride = FFALIGN(width, 8);
674  int height = s->plane[p].band[l][0].height;
675 
676  bytestream2_put_be16(pby, BitstreamMarker);
677  bytestream2_put_be16(pby, 0x0d0d);
678 
679  bytestream2_put_be16(pby, WaveletType);
680  bytestream2_put_be16(pby, 3 + 2 * (l == 2));
681 
682  bytestream2_put_be16(pby, WaveletNumber);
683  bytestream2_put_be16(pby, 3 - l);
684 
685  bytestream2_put_be16(pby, WaveletLevel);
686  bytestream2_put_be16(pby, 3 - l);
687 
688  bytestream2_put_be16(pby, NumBands);
689  bytestream2_put_be16(pby, 4);
690 
691  bytestream2_put_be16(pby, HighpassWidth);
692  bytestream2_put_be16(pby, width);
693 
694  bytestream2_put_be16(pby, HighpassHeight);
695  bytestream2_put_be16(pby, height);
696 
697  bytestream2_put_be16(pby, LowpassBorder);
698  bytestream2_put_be16(pby, 0);
699 
700  bytestream2_put_be16(pby, HighpassBorder);
701  bytestream2_put_be16(pby, 0);
702 
703  bytestream2_put_be16(pby, LowpassScale);
704  bytestream2_put_be16(pby, 1);
705 
706  bytestream2_put_be16(pby, LowpassDivisor);
707  bytestream2_put_be16(pby, 1);
708 
709  for (int i = 0; i < 3; i++) {
710  int16_t *data = s->plane[p].subband[1 + l * 3 + i];
711  int count = 0, padd = 0;
712 
713  bytestream2_put_be16(pby, BitstreamMarker);
714  bytestream2_put_be16(pby, 0x0e0e);
715 
716  bytestream2_put_be16(pby, SubbandNumber);
717  bytestream2_put_be16(pby, i + 1);
718 
719  bytestream2_put_be16(pby, BandCodingFlags);
720  bytestream2_put_be16(pby, 1);
721 
722  bytestream2_put_be16(pby, BandWidth);
723  bytestream2_put_be16(pby, width);
724 
725  bytestream2_put_be16(pby, BandHeight);
726  bytestream2_put_be16(pby, height);
727 
728  bytestream2_put_be16(pby, SubbandBand);
729  bytestream2_put_be16(pby, 1 + l * 3 + i);
730 
731  bytestream2_put_be16(pby, BandEncoding);
732  bytestream2_put_be16(pby, 3);
733 
734  bytestream2_put_be16(pby, Quantization);
735  bytestream2_put_be16(pby, s->plane[p].quantization[1 + l * 3 + i]);
736 
737  bytestream2_put_be16(pby, BandScale);
738  bytestream2_put_be16(pby, 1);
739 
740  bytestream2_put_be16(pby, BandHeader);
741  bytestream2_put_be16(pby, 0);
742 
743  quantize_band(data, width, a_width, height,
744  s->plane[p].quantization[1 + l * 3 + i]);
745 
747 
748  for (int m = 0; m < height; m++) {
749  for (int j = 0; j < stride; j++) {
750  int16_t index = j >= width ? 0 : FFSIGN(data[j]) * lut[FFABS(data[j])];
751 
752  if (index < 0)
753  index += 512;
754  if (index == 0) {
755  count++;
756  continue;
757  } else if (count > 0) {
758  count = put_runcode(pb, count, rb);
759  }
760 
761  put_bits(pb, cb[index].size, cb[index].bits);
762  }
763 
764  data += a_width;
765  }
766 
767  if (count > 0) {
768  count = put_runcode(pb, count, rb);
769  }
770 
771  put_bits(pb, cb[512].size, cb[512].bits);
772 
773  flush_put_bits(pb);
774  bytestream2_skip_p(pby, put_bits_count(pb) >> 3);
775  padd = (4 - (bytestream2_tell_p(pby) & 3)) & 3;
776  while (padd--)
777  bytestream2_put_byte(pby, 0);
778 
779  bytestream2_put_be16(pby, BandTrailer);
780  bytestream2_put_be16(pby, 0);
781  }
782 
783  bytestream2_put_be16(pby, BitstreamMarker);
784  bytestream2_put_be16(pby, 0x0c0c);
785  }
786 
787  s->plane[p].size = bytestream2_tell_p(pby) - pos;
788  }
789 
790  bytestream2_put_be16(pby, GroupTrailer);
791  bytestream2_put_be16(pby, 0);
792 
794 
796 
797  bytestream2_seek_p(pby, 8, SEEK_SET);
798  for (int i = 0; i < s->planes; i++)
799  bytestream2_put_be32(pby, s->plane[i].size);
800 
801  *got_packet = 1;
802 
803  return 0;
804 }
805 
807 {
808  CFHDEncContext *s = avctx->priv_data;
809 
810  for (int i = 0; i < s->planes; i++) {
811  av_freep(&s->plane[i].dwt_buf);
812  av_freep(&s->plane[i].dwt_tmp);
813 
814  for (int j = 0; j < SUBBAND_COUNT; j++)
815  s->plane[i].subband[j] = NULL;
816 
817  for (int j = 0; j < 8; j++)
818  s->plane[i].l_h[j] = NULL;
819  }
820 
821  av_freep(&s->alpha);
822 
823  return 0;
824 }
825 
826 #define OFFSET(x) offsetof(CFHDEncContext, x)
827 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
828 static const AVOption options[] = {
829  { "quality", "set quality", OFFSET(quality), AV_OPT_TYPE_INT, {.i64= 0}, 0, 12, VE, "q" },
830  { "film3+", NULL, 0, AV_OPT_TYPE_CONST, {.i64= 0}, 0, 0, VE, "q" },
831  { "film3", NULL, 0, AV_OPT_TYPE_CONST, {.i64= 1}, 0, 0, VE, "q" },
832  { "film2+", NULL, 0, AV_OPT_TYPE_CONST, {.i64= 2}, 0, 0, VE, "q" },
833  { "film2", NULL, 0, AV_OPT_TYPE_CONST, {.i64= 3}, 0, 0, VE, "q" },
834  { "film1.5", NULL, 0, AV_OPT_TYPE_CONST, {.i64= 4}, 0, 0, VE, "q" },
835  { "film1+", NULL, 0, AV_OPT_TYPE_CONST, {.i64= 5}, 0, 0, VE, "q" },
836  { "film1", NULL, 0, AV_OPT_TYPE_CONST, {.i64= 6}, 0, 0, VE, "q" },
837  { "high+", NULL, 0, AV_OPT_TYPE_CONST, {.i64= 7}, 0, 0, VE, "q" },
838  { "high", NULL, 0, AV_OPT_TYPE_CONST, {.i64= 8}, 0, 0, VE, "q" },
839  { "medium+", NULL, 0, AV_OPT_TYPE_CONST, {.i64= 9}, 0, 0, VE, "q" },
840  { "medium", NULL, 0, AV_OPT_TYPE_CONST, {.i64=10}, 0, 0, VE, "q" },
841  { "low+", NULL, 0, AV_OPT_TYPE_CONST, {.i64=11}, 0, 0, VE, "q" },
842  { "low", NULL, 0, AV_OPT_TYPE_CONST, {.i64=12}, 0, 0, VE, "q" },
843  { NULL},
844 };
845 
846 static const AVClass cfhd_class = {
847  .class_name = "cfhd",
848  .item_name = av_default_item_name,
849  .option = options,
850  .version = LIBAVUTIL_VERSION_INT,
851 };
852 
854  .name = "cfhd",
855  .long_name = NULL_IF_CONFIG_SMALL("GoPro CineForm HD"),
856  .type = AVMEDIA_TYPE_VIDEO,
857  .id = AV_CODEC_ID_CFHD,
858  .priv_data_size = sizeof(CFHDEncContext),
859  .priv_class = &cfhd_class,
861  .close = cfhd_encode_close,
862  .encode2 = cfhd_encode_frame,
863  .capabilities = AV_CODEC_CAP_FRAME_THREADS,
864  .pix_fmts = (const enum AVPixelFormat[]) {
869  },
870  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
871 };
int32_t SampleType
Definition: ac3enc.h:63
#define av_cold
Definition: attributes.h:88
simple assert() macros that are a bit more flexible than ISO C assert().
Libavcodec external API header.
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
static av_always_inline void bytestream2_init_writer(PutByteContext *p, uint8_t *buf, int buf_size)
Definition: bytestream.h:147
static av_always_inline int bytestream2_tell_p(PutByteContext *p)
Definition: bytestream.h:197
static av_always_inline void bytestream2_skip_p(PutByteContext *p, unsigned int size)
Definition: bytestream.h:180
static av_always_inline int bytestream2_get_bytes_left_p(PutByteContext *p)
Definition: bytestream.h:163
static av_always_inline int bytestream2_seek_p(PutByteContext *p, int offset, int whence)
Definition: bytestream.h:236
#define s(width, name)
Definition: cbs_vp9.c:257
#define DWT_LEVELS
Definition: cfhd.h:108
#define SUBBAND_COUNT
Definition: cfhd.h:99
@ Quantization
Definition: cfhd.h:76
@ FrameNumber
Definition: cfhd.h:82
@ SampleFlags
Definition: cfhd.h:81
@ BandHeight
Definition: cfhd.h:73
@ NumSpatial
Definition: cfhd.h:47
@ NumLevels
Definition: cfhd.h:55
@ HighpassWidth
Definition: cfhd.h:65
@ SampleIndexTable
Definition: cfhd.h:36
@ FirstWavelet
Definition: cfhd.h:48
@ EncodedFormat
Definition: cfhd.h:92
@ BandWidth
Definition: cfhd.h:72
@ LowpassHeight
Definition: cfhd.h:57
@ WaveletCount
Definition: cfhd.h:45
@ LowpassPrecision
Definition: cfhd.h:60
@ SubbandNumber
Definition: cfhd.h:71
@ BandHeader
Definition: cfhd.h:78
@ BitstreamMarker
Definition: cfhd.h:37
@ LowpassScale
Definition: cfhd.h:69
@ PrescaleTable
Definition: cfhd.h:91
@ HighpassHeight
Definition: cfhd.h:66
@ BandTrailer
Definition: cfhd.h:79
@ LowpassSubband
Definition: cfhd.h:54
@ PixelOffset
Definition: cfhd.h:58
@ BandScale
Definition: cfhd.h:77
@ ImageWidth
Definition: cfhd.h:51
@ LowpassWidth
Definition: cfhd.h:56
@ BandEncoding
Definition: cfhd.h:75
@ LowpassBorder
Definition: cfhd.h:67
@ NumFrames
Definition: cfhd.h:43
@ WaveletType
Definition: cfhd.h:61
@ WaveletNumber
Definition: cfhd.h:62
@ BandCodingFlags
Definition: cfhd.h:85
@ HighpassBorder
Definition: cfhd.h:68
@ Precision
Definition: cfhd.h:83
@ GroupTrailer
Definition: cfhd.h:49
@ ChannelCount
Definition: cfhd.h:44
@ NumBands
Definition: cfhd.h:64
@ LowpassDivisor
Definition: cfhd.h:70
@ ImageHeight
Definition: cfhd.h:52
@ SubbandBand
Definition: cfhd.h:74
@ ChannelNumber
Definition: cfhd.h:80
@ SubbandCount
Definition: cfhd.h:46
@ LowpassQuantization
Definition: cfhd.h:59
@ WaveletLevel
Definition: cfhd.h:63
static const unsigned codebook[256][2]
Definition: cfhdenc.c:42
AVCodec ff_cfhd_encoder
Definition: cfhdenc.c:853
static const AVOption options[]
Definition: cfhdenc.c:828
#define VE
Definition: cfhdenc.c:827
static av_cold int cfhd_encode_init(AVCodecContext *avctx)
Definition: cfhdenc.c:247
static int put_runcode(PutBitContext *pb, int count, const Runbook *const rb)
Definition: cfhdenc.c:394
static void process_alpha(const int16_t *src, int width, int height, ptrdiff_t stride, int16_t *dst)
Definition: cfhdenc.c:406
static const AVClass cfhd_class
Definition: cfhdenc.c:846
static int cfhd_encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *frame, int *got_packet)
Definition: cfhdenc.c:427
static av_cold int cfhd_encode_close(AVCodecContext *avctx)
Definition: cfhdenc.c:806
#define OFFSET(x)
Definition: cfhdenc.c:826
static const uint16_t quantization_per_subband[2][3][13][9]
Definition: cfhdenc.c:110
static void quantize_band(int16_t *input, int width, int a_width, int height, unsigned quantization)
Definition: cfhdenc.c:382
static const uint16_t runbook[18][3]
Definition: cfhdenc.c:98
av_cold void ff_cfhdencdsp_init(CFHDEncDSPContext *c)
Definition: cfhdencdsp.c:72
#define av_clip_intp2
Definition: common.h:143
#define FFMIN(a, b)
Definition: common.h:105
#define av_clip_uintp2
Definition: common.h:146
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
#define FFSIGN(a)
Definition: common.h:73
#define NULL
Definition: coverity.c:32
static AVFrame * frame
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int64_t min_size)
Check AVPacket size and/or allocate data.
Definition: encode.c:33
double value
Definition: eval.c:98
@ AV_OPT_TYPE_CONST
Definition: opt.h:234
@ AV_OPT_TYPE_INT
Definition: opt.h:225
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:108
@ AV_CODEC_ID_CFHD
Definition: codec_id.h:266
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:410
void av_shrink_packet(AVPacket *pkt, int size)
Reduce packet size, correctly zeroing padding.
Definition: avpacket.c:114
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
#define AVERROR(e)
Definition: error.h:43
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
void * av_calloc(size_t nmemb, size_t size)
Non-inlined equivalent of av_mallocz_array().
Definition: mem.c:245
void * av_mallocz_array(size_t nmemb, size_t size)
Allocate a memory block for an array with av_mallocz().
Definition: mem.c:190
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
int index
Definition: gxfenc.c:89
for(j=16;j >0;--j)
static const int16_t alpha[]
Definition: ilbcdata.h:55
misc image utilities
int i
Definition: input.c:407
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:218
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: internal.h:49
common internal API header
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:309
int stride
Definition: mace.c:144
#define FFALIGN(x, a)
Definition: macros.h:48
const char data[16]
Definition: mxf.c:142
AVOptions.
int av_pix_fmt_count_planes(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2613
int av_pix_fmt_get_chroma_sub_sample(enum AVPixelFormat pix_fmt, int *h_shift, int *v_shift)
Utility function to access log2_chroma_w log2_chroma_h from the pixel format AVPixFmtDescriptor.
Definition: pixdesc.c:2601
#define AV_PIX_FMT_GBRAP12
Definition: pixfmt.h:420
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:400
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:416
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
bitstream writer API
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:57
static int put_bits_count(PutBitContext *s)
Definition: put_bits.h:76
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:110
#define FF_ARRAY_ELEMS(a)
unsigned int pos
Definition: spdifenc.c:412
Describe the class of an AVClass context structure.
Definition: log.h:67
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:72
main external API structure.
Definition: avcodec.h:536
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:746
int width
picture width / height.
Definition: avcodec.h:709
void * priv_data
Definition: avcodec.h:563
AVCodec.
Definition: codec.h:197
const char * name
Name of the codec implementation.
Definition: codec.h:204
This structure describes decoded (raw) audio or video data.
Definition: frame.h:318
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:411
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:332
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:349
AVOption.
Definition: opt.h:248
This structure stores compressed data.
Definition: packet.h:346
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:375
int size
Definition: packet.h:370
uint8_t * data
Definition: packet.h:369
int chroma_v_shift
Definition: cfhdenc.c:236
PutByteContext pby
Definition: cfhdenc.c:231
uint16_t lut[1024]
Definition: cfhdenc.c:239
CFHDEncDSPContext dsp
Definition: cfhdenc.c:244
Runbook rb[321]
Definition: cfhdenc.c:240
int16_t * alpha
Definition: cfhdenc.c:242
PlaneEnc plane[4]
Definition: cfhdenc.c:237
Codebook cb[513]
Definition: cfhdenc.c:241
int chroma_h_shift
Definition: cfhdenc.c:235
PutBitContext pb
Definition: cfhdenc.c:230
void(* horiz_filter)(int16_t *input, int16_t *low, int16_t *high, ptrdiff_t in_stride, ptrdiff_t low_stride, ptrdiff_t high_stride, int width, int height)
Definition: cfhdencdsp.h:26
void(* vert_filter)(int16_t *input, int16_t *low, int16_t *high, ptrdiff_t in_stride, ptrdiff_t low_stride, ptrdiff_t high_stride, int width, int height)
Definition: cfhdencdsp.h:31
unsigned size
Definition: cfhdenc.c:205
unsigned bits
Definition: cfhdenc.c:204
SubBand band[DWT_LEVELS][4]
Definition: cfhdenc.c:224
int16_t * dwt_buf
Definition: cfhdenc.c:217
unsigned quantization[SUBBAND_COUNT]
Definition: cfhdenc.c:220
int16_t * dwt_tmp
Definition: cfhdenc.c:218
int16_t * l_h[8]
Definition: cfhdenc.c:222
unsigned size
Definition: cfhdenc.c:215
int16_t * subband[SUBBAND_COUNT]
Definition: cfhdenc.c:221
unsigned bits
Definition: cfhdenc.c:210
unsigned size
Definition: cfhdenc.c:209
unsigned run
Definition: cfhdenc.c:211
Definition: cfhd.h:111
uint8_t run
Definition: svq3.c:205
#define av_malloc_array(a, b)
#define av_freep(p)
#define av_log(a,...)
#define src
Definition: vp8dsp.c:255
AVPacket * pkt
Definition: movenc.c:59
#define height
#define width
int size
static double cb(void *priv, double x, double y)
Definition: vf_geq.c:215
if(ret< 0)
Definition: vf_mcdeint.c:282
static const int factor[16]
Definition: vf_pp7.c:77
uint8_t bits
Definition: vp3data.h:141
TransformType
Definition: webp.c:110