FFmpeg
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/imgutils.h"
30 #include "libavutil/opt.h"
31 
32 #include "avcodec.h"
33 #include "bytestream.h"
34 #include "cfhd.h"
35 #include "cfhdencdsp.h"
36 #include "codec_internal.h"
37 #include "encode.h"
38 #include "put_bits.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 
220  unsigned quantization[SUBBAND_COUNT];
221  int16_t *subband[SUBBAND_COUNT];
222  int16_t *l_h[8];
223 
224  SubBand band[DWT_LEVELS][4];
225 } PlaneEnc;
226 
227 typedef struct CFHDEncContext {
228  const AVClass *class;
229 
230  PutBitContext pb;
231  PutByteContext pby;
232 
233  int quality;
234  int planes;
235  int chroma_h_shift;
236  int chroma_v_shift;
237  PlaneEnc plane[4];
238 
239  uint16_t lut[1024];
240  Runbook rb[321];
241  Codebook cb[513];
242  int16_t *alpha;
243 
244  CFHDEncDSPContext dsp;
245 } CFHDEncContext;
246 
247 static av_cold int cfhd_encode_init(AVCodecContext *avctx)
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 
255  ret = av_pix_fmt_get_chroma_sub_sample(avctx->pix_fmt,
256  &s->chroma_h_shift,
257  &s->chroma_v_shift);
258  if (ret < 0)
259  return ret;
260 
261  if (avctx->width & 15) {
262  av_log(avctx, AV_LOG_ERROR, "Width must be multiple of 16.\n");
263  return AVERROR_INVALIDDATA;
264  }
265 
266  s->planes = av_pix_fmt_count_planes(avctx->pix_fmt);
267 
268  for (int i = 0; i < s->planes; i++) {
269  int w8, h8, w4, h4, w2, h2;
270  int width = i ? avctx->width >> s->chroma_h_shift : avctx->width;
271  int height = i ? FFALIGN(avctx->height >> s->chroma_v_shift, 8) :
272  FFALIGN(avctx->height >> s->chroma_v_shift, 8);
273  ptrdiff_t stride = (FFALIGN(width / 8, 8) + 64) * 8;
274 
275  w8 = FFALIGN(width / 8, 8) + 64;
276  h8 = FFALIGN(height, 8) / 8;
277  w4 = w8 * 2;
278  h4 = h8 * 2;
279  w2 = w4 * 2;
280  h2 = h4 * 2;
281 
282  s->plane[i].dwt_buf =
283  av_calloc(height * stride, sizeof(*s->plane[i].dwt_buf));
284  s->plane[i].dwt_tmp =
285  av_malloc_array(height * stride, sizeof(*s->plane[i].dwt_tmp));
286  if (!s->plane[i].dwt_buf || !s->plane[i].dwt_tmp)
287  return AVERROR(ENOMEM);
288 
289  s->plane[i].subband[0] = s->plane[i].dwt_buf;
290  s->plane[i].subband[1] = s->plane[i].dwt_buf + 2 * w8 * h8;
291  s->plane[i].subband[2] = s->plane[i].dwt_buf + 1 * w8 * h8;
292  s->plane[i].subband[3] = s->plane[i].dwt_buf + 3 * w8 * h8;
293  s->plane[i].subband[4] = s->plane[i].dwt_buf + 2 * w4 * h4;
294  s->plane[i].subband[5] = s->plane[i].dwt_buf + 1 * w4 * h4;
295  s->plane[i].subband[6] = s->plane[i].dwt_buf + 3 * w4 * h4;
296  s->plane[i].subband[7] = s->plane[i].dwt_buf + 2 * w2 * h2;
297  s->plane[i].subband[8] = s->plane[i].dwt_buf + 1 * w2 * h2;
298  s->plane[i].subband[9] = s->plane[i].dwt_buf + 3 * w2 * h2;
299 
300  for (int j = 0; j < DWT_LEVELS; j++) {
301  for (int k = 0; k < FF_ARRAY_ELEMS(s->plane[i].band[j]); k++) {
302  s->plane[i].band[j][k].width = (width / 8) << j;
303  s->plane[i].band[j][k].height = (height / 8) << j;
304  s->plane[i].band[j][k].a_width = w8 << j;
305  s->plane[i].band[j][k].a_height = h8 << j;
306  }
307  }
308 
309  /* ll2 and ll1 commented out because they are done in-place */
310  s->plane[i].l_h[0] = s->plane[i].dwt_tmp;
311  s->plane[i].l_h[1] = s->plane[i].dwt_tmp + 2 * w8 * h8;
312  // s->plane[i].l_h[2] = ll2;
313  s->plane[i].l_h[3] = s->plane[i].dwt_tmp;
314  s->plane[i].l_h[4] = s->plane[i].dwt_tmp + 2 * w4 * h4;
315  // s->plane[i].l_h[5] = ll1;
316  s->plane[i].l_h[6] = s->plane[i].dwt_tmp;
317  s->plane[i].l_h[7] = s->plane[i].dwt_tmp + 2 * w2 * h2;
318  }
319 
320  for (int i = 0; i < 512; i++) {
321  int value = (i & sign_mask) ? twos_complement + (i & mag_mask): i;
322  int mag = FFMIN(FFABS(value), 255);
323 
324  if (mag) {
325  s->cb[i].bits = (codebook[mag][1] << 1) | (value > 0 ? 0 : 1);
326  s->cb[i].size = codebook[mag][0] + 1;
327  } else {
328  s->cb[i].bits = codebook[mag][1];
329  s->cb[i].size = codebook[mag][0];
330  }
331  }
332 
333  s->cb[512].bits = 0x3114ba3;
334  s->cb[512].size = 26;
335 
336  s->rb[0].run = 0;
337 
338  for (int i = 1, j = 0; i < 320 && j < 17; j++) {
339  int run = runbook[j][2];
340  int end = runbook[j+1][2];
341 
342  while (i < end) {
343  s->rb[i].run = run;
344  s->rb[i].bits = runbook[j][1];
345  s->rb[i++].size = runbook[j][0];
346  }
347  }
348 
349  s->rb[320].bits = runbook[17][1];
350  s->rb[320].size = runbook[17][0];
351  s->rb[320].run = 320;
352 
353  for (int i = 0; i < 256; i++) {
354  int idx = i + ((768LL * i * i * i) / (256 * 256 * 256));
355 
356  s->lut[idx] = i;
357  }
358  for (int i = 0; i < 1024; i++) {
359  if (s->lut[i])
360  last = s->lut[i];
361  else
362  s->lut[i] = last;
363  }
364 
365  ff_cfhdencdsp_init(&s->dsp);
366 
367  if (s->planes != 4)
368  return 0;
369 
370  s->alpha = av_calloc(avctx->width * avctx->height, sizeof(*s->alpha));
371  if (!s->alpha)
372  return AVERROR(ENOMEM);
373 
374  return 0;
375 }
376 
377 static void quantize_band(int16_t *input, int width, int a_width,
378  int height, unsigned quantization)
379 {
380  const int16_t factor = (uint32_t)(1U << 15) / quantization;
381 
382  for (int i = 0; i < height; i++) {
383  for (int j = 0; j < width; j++)
384  input[j] = av_clip_intp2(((input[j] * factor + 16384 * FFSIGN(input[j])) / 32768), 10);
385  input += a_width;
386  }
387 }
388 
389 static int put_runcode(PutBitContext *pb, int count, const Runbook *const rb)
390 {
391  while (count > 0) {
392  const int index = FFMIN(320, count);
393 
394  put_bits(pb, rb[index].size, rb[index].bits);
395  count -= rb[index].run;
396  }
397 
398  return 0;
399 }
400 
401 static void process_alpha(const int16_t *src, int width, int height, ptrdiff_t stride, int16_t *dst)
402 {
403  for (int i = 0; i < height; i++) {
404  for (int j = 0; j < width; j++) {
405  int alpha = src[j];
406 
407  if (alpha > 0 && alpha < 4080) {
408  alpha *= 223;
409  alpha += 128;
410  alpha >>= 8;
411  alpha += 256;
412  }
413 
414  dst[j] = av_clip_uintp2(alpha, 12);
415  }
416 
417  src += stride;
418  dst += width;
419  }
420 }
421 
422 static int cfhd_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
423  const AVFrame *frame, int *got_packet)
424 {
425  CFHDEncContext *s = avctx->priv_data;
426  CFHDEncDSPContext *dsp = &s->dsp;
427  PutByteContext *pby = &s->pby;
428  PutBitContext *pb = &s->pb;
429  const Codebook *const cb = s->cb;
430  const Runbook *const rb = s->rb;
431  const uint16_t *lut = s->lut;
432  unsigned pos;
433  int ret;
434 
435  for (int plane = 0; plane < s->planes; plane++) {
436  int width = s->plane[plane].band[2][0].width;
437  int a_width = s->plane[plane].band[2][0].a_width;
438  int height = s->plane[plane].band[2][0].height;
439  int act_plane = plane == 1 ? 2 : plane == 2 ? 1 : plane;
440  const int16_t *input = (int16_t *)frame->data[act_plane];
441  int16_t *buf;
442  int16_t *low = s->plane[plane].l_h[6];
443  int16_t *high = s->plane[plane].l_h[7];
444  ptrdiff_t in_stride = frame->linesize[act_plane] / 2;
445  int low_stride, high_stride;
446 
447  if (plane == 3) {
448  process_alpha(input, avctx->width, avctx->height,
449  in_stride, s->alpha);
450  input = s->alpha;
451  in_stride = avctx->width;
452  }
453 
454  dsp->horiz_filter(input, low, high,
455  in_stride, a_width, a_width,
456  width * 2, height * 2);
457 
458  input = s->plane[plane].l_h[7];
459  low = s->plane[plane].subband[7];
460  low_stride = s->plane[plane].band[2][0].a_width;
461  high = s->plane[plane].subband[9];
462  high_stride = s->plane[plane].band[2][0].a_width;
463 
464  dsp->vert_filter(input, low, high,
465  a_width, low_stride, high_stride,
466  width, height * 2);
467 
468  input = s->plane[plane].l_h[6];
469  low = s->plane[plane].l_h[7];
470  high = s->plane[plane].subband[8];
471 
472  dsp->vert_filter(input, low, high,
473  a_width, low_stride, high_stride,
474  width, height * 2);
475 
476  a_width = s->plane[plane].band[1][0].a_width;
477  width = s->plane[plane].band[1][0].width;
478  height = s->plane[plane].band[1][0].height;
479  input = s->plane[plane].l_h[7];
480  low = s->plane[plane].l_h[3];
481  low_stride = s->plane[plane].band[1][0].a_width;
482  high = s->plane[plane].l_h[4];
483  high_stride = s->plane[plane].band[1][0].a_width;
484 
485  buf = s->plane[plane].l_h[7];
486  for (int i = 0; i < height * 2; i++) {
487  for (int j = 0; j < width * 2; j++)
488  buf[j] /= 4;
489  buf += a_width * 2;
490  }
491 
492  dsp->horiz_filter(input, low, high,
493  a_width * 2, low_stride, high_stride,
494  width * 2, height * 2);
495 
496  input = s->plane[plane].l_h[4];
497  low = s->plane[plane].subband[4];
498  high = s->plane[plane].subband[6];
499 
500  dsp->vert_filter(input, low, high,
501  a_width, low_stride, high_stride,
502  width, height * 2);
503 
504  input = s->plane[plane].l_h[3];
505  low = s->plane[plane].l_h[4];
506  high = s->plane[plane].subband[5];
507 
508  dsp->vert_filter(input, low, high,
509  a_width, low_stride, high_stride,
510  width, height * 2);
511 
512  a_width = s->plane[plane].band[0][0].a_width;
513  width = s->plane[plane].band[0][0].width;
514  height = s->plane[plane].band[0][0].height;
515  input = s->plane[plane].l_h[4];
516  low = s->plane[plane].l_h[0];
517  low_stride = s->plane[plane].band[0][0].a_width;
518  high = s->plane[plane].l_h[1];
519  high_stride = s->plane[plane].band[0][0].a_width;
520 
521  if (avctx->pix_fmt != AV_PIX_FMT_YUV422P10) {
522  int16_t *buf = s->plane[plane].l_h[4];
523  for (int i = 0; i < height * 2; i++) {
524  for (int j = 0; j < width * 2; j++)
525  buf[j] /= 4;
526  buf += a_width * 2;
527  }
528  }
529 
530  dsp->horiz_filter(input, low, high,
531  a_width * 2, low_stride, high_stride,
532  width * 2, height * 2);
533 
534  low = s->plane[plane].subband[1];
535  high = s->plane[plane].subband[3];
536  input = s->plane[plane].l_h[1];
537 
538  dsp->vert_filter(input, low, high,
539  a_width, low_stride, high_stride,
540  width, height * 2);
541 
542  low = s->plane[plane].subband[0];
543  high = s->plane[plane].subband[2];
544  input = s->plane[plane].l_h[0];
545 
546  dsp->vert_filter(input, low, high,
547  a_width, low_stride, high_stride,
548  width, height * 2);
549  }
550 
551  ret = ff_alloc_packet(avctx, pkt, 64LL + s->planes * (2LL * avctx->width * avctx->height + 1000LL));
552  if (ret < 0)
553  return ret;
554 
555  bytestream2_init_writer(pby, pkt->data, pkt->size);
556 
557  bytestream2_put_be16(pby, SampleType);
558  bytestream2_put_be16(pby, 9);
559 
560  bytestream2_put_be16(pby, SampleIndexTable);
561  bytestream2_put_be16(pby, s->planes);
562 
563  for (int i = 0; i < s->planes; i++)
564  bytestream2_put_be32(pby, 0);
565 
566  bytestream2_put_be16(pby, TransformType);
567  bytestream2_put_be16(pby, 0);
568 
569  bytestream2_put_be16(pby, NumFrames);
570  bytestream2_put_be16(pby, 1);
571 
572  bytestream2_put_be16(pby, ChannelCount);
573  bytestream2_put_be16(pby, s->planes);
574 
575  bytestream2_put_be16(pby, EncodedFormat);
576  bytestream2_put_be16(pby, avctx->pix_fmt == AV_PIX_FMT_YUV422P10 ? 1 : 3 + (s->planes == 4));
577 
578  bytestream2_put_be16(pby, WaveletCount);
579  bytestream2_put_be16(pby, 3);
580 
581  bytestream2_put_be16(pby, SubbandCount);
582  bytestream2_put_be16(pby, SUBBAND_COUNT);
583 
584  bytestream2_put_be16(pby, NumSpatial);
585  bytestream2_put_be16(pby, 2);
586 
587  bytestream2_put_be16(pby, FirstWavelet);
588  bytestream2_put_be16(pby, 3);
589 
590  bytestream2_put_be16(pby, ImageWidth);
591  bytestream2_put_be16(pby, avctx->width);
592 
593  bytestream2_put_be16(pby, ImageHeight);
594  bytestream2_put_be16(pby, avctx->height);
595 
596  bytestream2_put_be16(pby, -FrameNumber);
597  bytestream2_put_be16(pby, frame->pts & 0xFFFF);
598 
599  bytestream2_put_be16(pby, Precision);
600  bytestream2_put_be16(pby, avctx->pix_fmt == AV_PIX_FMT_YUV422P10 ? 10 : 12);
601 
602  bytestream2_put_be16(pby, PrescaleTable);
603  bytestream2_put_be16(pby, avctx->pix_fmt == AV_PIX_FMT_YUV422P10 ? 0x2000 : 0x2800);
604 
605  bytestream2_put_be16(pby, SampleFlags);
606  bytestream2_put_be16(pby, 1);
607 
608  for (int p = 0; p < s->planes; p++) {
609  int width = s->plane[p].band[0][0].width;
610  int a_width = s->plane[p].band[0][0].a_width;
611  int height = s->plane[p].band[0][0].height;
612  int16_t *data = s->plane[p].subband[0];
613 
614  if (p) {
615  bytestream2_put_be16(pby, SampleType);
616  bytestream2_put_be16(pby, 3);
617 
618  bytestream2_put_be16(pby, ChannelNumber);
619  bytestream2_put_be16(pby, p);
620  }
621 
622  bytestream2_put_be16(pby, BitstreamMarker);
623  bytestream2_put_be16(pby, 0x1a4a);
624 
625  pos = bytestream2_tell_p(pby);
626 
627  bytestream2_put_be16(pby, LowpassSubband);
628  bytestream2_put_be16(pby, 0);
629 
630  bytestream2_put_be16(pby, NumLevels);
631  bytestream2_put_be16(pby, 3);
632 
633  bytestream2_put_be16(pby, LowpassWidth);
634  bytestream2_put_be16(pby, width);
635 
636  bytestream2_put_be16(pby, LowpassHeight);
637  bytestream2_put_be16(pby, height);
638 
639  bytestream2_put_be16(pby, PixelOffset);
640  bytestream2_put_be16(pby, 0);
641 
642  bytestream2_put_be16(pby, LowpassQuantization);
643  bytestream2_put_be16(pby, 1);
644 
645  bytestream2_put_be16(pby, LowpassPrecision);
646  bytestream2_put_be16(pby, 16);
647 
648  bytestream2_put_be16(pby, BitstreamMarker);
649  bytestream2_put_be16(pby, 0x0f0f);
650 
651  for (int i = 0; i < height; i++) {
652  for (int j = 0; j < width; j++)
653  bytestream2_put_be16(pby, data[j]);
654  data += a_width;
655  }
656 
657  bytestream2_put_be16(pby, BitstreamMarker);
658  bytestream2_put_be16(pby, 0x1b4b);
659 
660  for (int l = 0; l < 3; l++) {
661  for (int i = 0; i < 3; i++) {
662  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];
663  }
664  }
665 
666  for (int l = 0; l < 3; l++) {
667  int a_width = s->plane[p].band[l][0].a_width;
668  int width = s->plane[p].band[l][0].width;
669  int stride = FFALIGN(width, 8);
670  int height = s->plane[p].band[l][0].height;
671 
672  bytestream2_put_be16(pby, BitstreamMarker);
673  bytestream2_put_be16(pby, 0x0d0d);
674 
675  bytestream2_put_be16(pby, WaveletType);
676  bytestream2_put_be16(pby, 3 + 2 * (l == 2));
677 
678  bytestream2_put_be16(pby, WaveletNumber);
679  bytestream2_put_be16(pby, 3 - l);
680 
681  bytestream2_put_be16(pby, WaveletLevel);
682  bytestream2_put_be16(pby, 3 - l);
683 
684  bytestream2_put_be16(pby, NumBands);
685  bytestream2_put_be16(pby, 4);
686 
687  bytestream2_put_be16(pby, HighpassWidth);
688  bytestream2_put_be16(pby, width);
689 
690  bytestream2_put_be16(pby, HighpassHeight);
691  bytestream2_put_be16(pby, height);
692 
693  bytestream2_put_be16(pby, LowpassBorder);
694  bytestream2_put_be16(pby, 0);
695 
696  bytestream2_put_be16(pby, HighpassBorder);
697  bytestream2_put_be16(pby, 0);
698 
699  bytestream2_put_be16(pby, LowpassScale);
700  bytestream2_put_be16(pby, 1);
701 
702  bytestream2_put_be16(pby, LowpassDivisor);
703  bytestream2_put_be16(pby, 1);
704 
705  for (int i = 0; i < 3; i++) {
706  int16_t *data = s->plane[p].subband[1 + l * 3 + i];
707  int count = 0, padd = 0;
708 
709  bytestream2_put_be16(pby, BitstreamMarker);
710  bytestream2_put_be16(pby, 0x0e0e);
711 
712  bytestream2_put_be16(pby, SubbandNumber);
713  bytestream2_put_be16(pby, i + 1);
714 
715  bytestream2_put_be16(pby, BandCodingFlags);
716  bytestream2_put_be16(pby, 1);
717 
718  bytestream2_put_be16(pby, BandWidth);
719  bytestream2_put_be16(pby, width);
720 
721  bytestream2_put_be16(pby, BandHeight);
722  bytestream2_put_be16(pby, height);
723 
724  bytestream2_put_be16(pby, SubbandBand);
725  bytestream2_put_be16(pby, 1 + l * 3 + i);
726 
727  bytestream2_put_be16(pby, BandEncoding);
728  bytestream2_put_be16(pby, 3);
729 
730  bytestream2_put_be16(pby, Quantization);
731  bytestream2_put_be16(pby, s->plane[p].quantization[1 + l * 3 + i]);
732 
733  bytestream2_put_be16(pby, BandScale);
734  bytestream2_put_be16(pby, 1);
735 
736  bytestream2_put_be16(pby, BandHeader);
737  bytestream2_put_be16(pby, 0);
738 
739  quantize_band(data, width, a_width, height,
740  s->plane[p].quantization[1 + l * 3 + i]);
741 
742  init_put_bits(pb, pkt->data + bytestream2_tell_p(pby), bytestream2_get_bytes_left_p(pby));
743 
744  for (int m = 0; m < height; m++) {
745  for (int j = 0; j < stride; j++) {
746  int16_t index = j >= width ? 0 : FFSIGN(data[j]) * lut[FFABS(data[j])];
747 
748  if (index < 0)
749  index += 512;
750  if (index == 0) {
751  count++;
752  continue;
753  } else if (count > 0) {
754  count = put_runcode(pb, count, rb);
755  }
756 
757  put_bits(pb, cb[index].size, cb[index].bits);
758  }
759 
760  data += a_width;
761  }
762 
763  if (count > 0) {
764  count = put_runcode(pb, count, rb);
765  }
766 
767  put_bits(pb, cb[512].size, cb[512].bits);
768 
769  flush_put_bits(pb);
770  bytestream2_skip_p(pby, put_bytes_output(pb));
771  padd = (4 - (bytestream2_tell_p(pby) & 3)) & 3;
772  while (padd--)
773  bytestream2_put_byte(pby, 0);
774 
775  bytestream2_put_be16(pby, BandTrailer);
776  bytestream2_put_be16(pby, 0);
777  }
778 
779  bytestream2_put_be16(pby, BitstreamMarker);
780  bytestream2_put_be16(pby, 0x0c0c);
781  }
782 
783  s->plane[p].size = bytestream2_tell_p(pby) - pos;
784  }
785 
786  bytestream2_put_be16(pby, GroupTrailer);
787  bytestream2_put_be16(pby, 0);
788 
789  av_shrink_packet(pkt, bytestream2_tell_p(pby));
790 
791  pkt->flags |= AV_PKT_FLAG_KEY;
792 
793  bytestream2_seek_p(pby, 8, SEEK_SET);
794  for (int i = 0; i < s->planes; i++)
795  bytestream2_put_be32(pby, s->plane[i].size);
796 
797  *got_packet = 1;
798 
799  return 0;
800 }
801 
802 static av_cold int cfhd_encode_close(AVCodecContext *avctx)
803 {
804  CFHDEncContext *s = avctx->priv_data;
805 
806  for (int i = 0; i < s->planes; i++) {
807  av_freep(&s->plane[i].dwt_buf);
808  av_freep(&s->plane[i].dwt_tmp);
809 
810  for (int j = 0; j < SUBBAND_COUNT; j++)
811  s->plane[i].subband[j] = NULL;
812 
813  for (int j = 0; j < 8; j++)
814  s->plane[i].l_h[j] = NULL;
815  }
816 
817  av_freep(&s->alpha);
818 
819  return 0;
820 }
821 
822 #define OFFSET(x) offsetof(CFHDEncContext, x)
823 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
824 static const AVOption options[] = {
825  { "quality", "set quality", OFFSET(quality), AV_OPT_TYPE_INT, {.i64= 0}, 0, 12, VE, "q" },
826  { "film3+", NULL, 0, AV_OPT_TYPE_CONST, {.i64= 0}, 0, 0, VE, "q" },
827  { "film3", NULL, 0, AV_OPT_TYPE_CONST, {.i64= 1}, 0, 0, VE, "q" },
828  { "film2+", NULL, 0, AV_OPT_TYPE_CONST, {.i64= 2}, 0, 0, VE, "q" },
829  { "film2", NULL, 0, AV_OPT_TYPE_CONST, {.i64= 3}, 0, 0, VE, "q" },
830  { "film1.5", NULL, 0, AV_OPT_TYPE_CONST, {.i64= 4}, 0, 0, VE, "q" },
831  { "film1+", NULL, 0, AV_OPT_TYPE_CONST, {.i64= 5}, 0, 0, VE, "q" },
832  { "film1", NULL, 0, AV_OPT_TYPE_CONST, {.i64= 6}, 0, 0, VE, "q" },
833  { "high+", NULL, 0, AV_OPT_TYPE_CONST, {.i64= 7}, 0, 0, VE, "q" },
834  { "high", NULL, 0, AV_OPT_TYPE_CONST, {.i64= 8}, 0, 0, VE, "q" },
835  { "medium+", NULL, 0, AV_OPT_TYPE_CONST, {.i64= 9}, 0, 0, VE, "q" },
836  { "medium", NULL, 0, AV_OPT_TYPE_CONST, {.i64=10}, 0, 0, VE, "q" },
837  { "low+", NULL, 0, AV_OPT_TYPE_CONST, {.i64=11}, 0, 0, VE, "q" },
838  { "low", NULL, 0, AV_OPT_TYPE_CONST, {.i64=12}, 0, 0, VE, "q" },
839  { NULL},
840 };
841 
842 static const AVClass cfhd_class = {
843  .class_name = "cfhd",
844  .item_name = av_default_item_name,
845  .option = options,
846  .version = LIBAVUTIL_VERSION_INT,
847 };
848 
849 const FFCodec ff_cfhd_encoder = {
850  .p.name = "cfhd",
851  CODEC_LONG_NAME("GoPro CineForm HD"),
852  .p.type = AVMEDIA_TYPE_VIDEO,
853  .p.id = AV_CODEC_ID_CFHD,
854  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS,
855  .priv_data_size = sizeof(CFHDEncContext),
856  .p.priv_class = &cfhd_class,
857  .init = cfhd_encode_init,
858  .close = cfhd_encode_close,
859  FF_CODEC_ENCODE_CB(cfhd_encode_frame),
860  .p.pix_fmts = (const enum AVPixelFormat[]) {
861  AV_PIX_FMT_YUV422P10,
862  AV_PIX_FMT_GBRP12,
863  AV_PIX_FMT_GBRAP12,
864  AV_PIX_FMT_NONE
865  },
866  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
867 };
Runbook::run
unsigned run
Definition: cfhdenc.c:211
ChannelNumber
@ ChannelNumber
Definition: cfhd.h:77
ChannelCount
@ ChannelCount
Definition: cfhd.h:41
process_alpha
static void process_alpha(const int16_t *src, int width, int height, ptrdiff_t stride, int16_t *dst)
Definition: cfhdenc.c:401
LowpassSubband
@ LowpassSubband
Definition: cfhd.h:51
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
Precision
@ Precision
Definition: cfhd.h:80
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: codec_internal.h:42
GroupTrailer
@ GroupTrailer
Definition: cfhd.h:46
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
VE
#define VE
Definition: cfhdenc.c:823
BandHeader
@ BandHeader
Definition: cfhd.h:75
quantization_per_subband
static const uint16_t quantization_per_subband[2][3][13][9]
Definition: cfhdenc.c:110
PrescaleTable
@ PrescaleTable
Definition: cfhd.h:88
put_bytes_output
static int put_bytes_output(const PutBitContext *s)
Definition: put_bits.h:89
cb
static double cb(void *priv, double x, double y)
Definition: vf_geq.c:239
BandHeight
@ BandHeight
Definition: cfhd.h:70
cfhd_class
static const AVClass cfhd_class
Definition: cfhdenc.c:842
av_clip_uintp2
#define av_clip_uintp2
Definition: common.h:119
PlaneEnc::quantization
unsigned quantization[SUBBAND_COUNT]
Definition: cfhdenc.c:220
init_put_bits
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:62
WaveletCount
@ WaveletCount
Definition: cfhd.h:42
NumSpatial
@ NumSpatial
Definition: cfhd.h:44
SampleType
int32_t SampleType
Definition: ac3enc.h:66
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:325
put_bits
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:221
AVPacket::data
uint8_t * data
Definition: packet.h:374
AVOption
AVOption.
Definition: opt.h:251
encode.h
BandScale
@ BandScale
Definition: cfhd.h:74
HighpassWidth
@ HighpassWidth
Definition: cfhd.h:62
bytestream2_tell_p
static av_always_inline int bytestream2_tell_p(PutByteContext *p)
Definition: bytestream.h:197
data
const char data[16]
Definition: mxf.c:146
Runbook::bits
unsigned bits
Definition: cfhdenc.c:210
WaveletNumber
@ WaveletNumber
Definition: cfhd.h:59
FFCodec
Definition: codec_internal.h:119
FrameNumber
@ FrameNumber
Definition: cfhd.h:79
LowpassWidth
@ LowpassWidth
Definition: cfhd.h:53
CFHDEncContext::plane
PlaneEnc plane[4]
Definition: cfhdenc.c:237
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:429
thread.h
quality
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But a word about quality
Definition: rate_distortion.txt:12
LowpassQuantization
@ LowpassQuantization
Definition: cfhd.h:56
av_pix_fmt_count_planes
int av_pix_fmt_count_planes(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2900
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:123
cfhd.h
CFHDEncContext::planes
int planes
Definition: cfhdenc.c:234
Codebook::bits
unsigned bits
Definition: cfhdenc.c:204
av_shrink_packet
void av_shrink_packet(AVPacket *pkt, int size)
Reduce packet size, correctly zeroing padding.
Definition: avpacket.c:112
FFSIGN
#define FFSIGN(a)
Definition: common.h:65
LowpassDivisor
@ LowpassDivisor
Definition: cfhd.h:67
WaveletLevel
@ WaveletLevel
Definition: cfhd.h:60
DWT_LEVELS
#define DWT_LEVELS
Definition: cfhd.h:105
FirstWavelet
@ FirstWavelet
Definition: cfhd.h:45
av_pix_fmt_get_chroma_sub_sample
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:2888
LowpassPrecision
@ LowpassPrecision
Definition: cfhd.h:57
FF_CODEC_ENCODE_CB
#define FF_CODEC_ENCODE_CB(func)
Definition: codec_internal.h:288
Quantization
@ Quantization
Definition: cfhd.h:73
Runbook
Definition: cfhdenc.c:208
BandEncoding
@ BandEncoding
Definition: cfhd.h:72
WaveletType
@ WaveletType
Definition: cfhd.h:58
SubbandNumber
@ SubbandNumber
Definition: cfhd.h:68
NumFrames
@ NumFrames
Definition: cfhd.h:40
pkt
AVPacket * pkt
Definition: movenc.c:59
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
bytestream2_get_bytes_left_p
static av_always_inline int bytestream2_get_bytes_left_p(PutByteContext *p)
Definition: bytestream.h:163
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:90
PlaneEnc::dwt_buf
int16_t * dwt_buf
Definition: cfhdenc.c:217
bytestream2_init_writer
static av_always_inline void bytestream2_init_writer(PutByteContext *p, uint8_t *buf, int buf_size)
Definition: bytestream.h:147
options
static const AVOption options[]
Definition: cfhdenc.c:824
AV_CODEC_ID_CFHD
@ AV_CODEC_ID_CFHD
Definition: codec_id.h:270
width
#define width
s
#define s(width, name)
Definition: cbs_vp9.c:256
AV_PIX_FMT_GBRAP12
#define AV_PIX_FMT_GBRAP12
Definition: pixfmt.h:452
TransformType
TransformType
Definition: webp.c:112
LowpassScale
@ LowpassScale
Definition: cfhd.h:66
bits
uint8_t bits
Definition: vp3data.h:141
cfhd_encode_init
static av_cold int cfhd_encode_init(AVCodecContext *avctx)
Definition: cfhdenc.c:247
cfhd_encode_frame
static int cfhd_encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *frame, int *got_packet)
Definition: cfhdenc.c:422
cfhd_encode_close
static av_cold int cfhd_encode_close(AVCodecContext *avctx)
Definition: cfhdenc.c:802
PutBitContext
Definition: put_bits.h:50
PlaneEnc
Definition: cfhdenc.c:214
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:264
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:64
if
if(ret)
Definition: filter_design.txt:179
AV_CODEC_CAP_FRAME_THREADS
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:113
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
PlaneEnc::subband
int16_t * subband[SUBBAND_COUNT]
Definition: cfhdenc.c:221
Codebook::size
unsigned size
Definition: cfhdenc.c:205
NULL
#define NULL
Definition: coverity.c:32
av_clip_intp2
#define av_clip_intp2
Definition: common.h:116
run
uint8_t run
Definition: svq3.c:203
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:432
CFHDEncContext::pby
PutByteContext pby
Definition: cfhdenc.c:231
HighpassHeight
@ HighpassHeight
Definition: cfhd.h:63
index
int index
Definition: gxfenc.c:89
SUBBAND_COUNT
#define SUBBAND_COUNT
Definition: cfhd.h:96
PutByteContext
Definition: bytestream.h:37
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
CFHDEncContext::lut
uint16_t lut[1024]
Definition: cfhdenc.c:239
AVPacket::size
int size
Definition: packet.h:375
codec_internal.h
CFHDEncContext::quality
int quality
Definition: cfhdenc.c:233
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:425
BitstreamMarker
@ BitstreamMarker
Definition: cfhd.h:34
PlaneEnc::size
unsigned size
Definition: cfhdenc.c:215
size
int size
Definition: twinvq_data.h:10344
Runbook::size
unsigned size
Definition: cfhdenc.c:209
cfhdencdsp.h
SubBand
Definition: cfhd.h:108
PlaneEnc::l_h
int16_t * l_h[8]
Definition: cfhdenc.c:222
height
#define height
CFHDEncDSPContext::vert_filter
void(* vert_filter)(const 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
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:380
input
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some input
Definition: filter_design.txt:172
CFHDEncContext
Definition: cfhdenc.c:227
NumBands
@ NumBands
Definition: cfhd.h:61
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
SubbandCount
@ SubbandCount
Definition: cfhd.h:43
bytestream2_skip_p
static av_always_inline void bytestream2_skip_p(PutByteContext *p, unsigned int size)
Definition: bytestream.h:180
AV_PIX_FMT_GBRP12
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:448
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:31
LowpassBorder
@ LowpassBorder
Definition: cfhd.h:64
SubbandBand
@ SubbandBand
Definition: cfhd.h:71
Codebook
Definition: cfhdenc.c:203
PlaneEnc::band
SubBand band[DWT_LEVELS][4]
Definition: cfhdenc.c:224
value
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default value
Definition: writing_filters.txt:86
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
CFHDEncContext::pb
PutBitContext pb
Definition: cfhdenc.c:230
PlaneEnc::dwt_tmp
int16_t * dwt_tmp
Definition: cfhdenc.c:218
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:211
CFHDEncDSPContext::horiz_filter
void(* horiz_filter)(const 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
AVCodecContext::height
int height
Definition: avcodec.h:571
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:608
ImageWidth
@ ImageWidth
Definition: cfhd.h:48
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:272
CFHDEncContext::chroma_h_shift
int chroma_h_shift
Definition: cfhdenc.c:235
avcodec.h
stride
#define stride
Definition: h264pred_template.c:537
ret
ret
Definition: filter_design.txt:187
AVClass::class_name
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:71
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
CFHDEncContext::dsp
CFHDEncDSPContext dsp
Definition: cfhdenc.c:244
pos
unsigned int pos
Definition: spdifenc.c:412
BandCodingFlags
@ BandCodingFlags
Definition: cfhd.h:82
U
#define U(x)
Definition: vpx_arith.h:37
EncodedFormat
@ EncodedFormat
Definition: cfhd.h:89
ff_cfhdencdsp_init
av_cold void ff_cfhdencdsp_init(CFHDEncDSPContext *c)
Definition: cfhdencdsp.c:71
AVCodecContext
main external API structure.
Definition: avcodec.h:398
runbook
static const uint16_t runbook[18][3]
Definition: cfhdenc.c:98
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
bytestream2_seek_p
static av_always_inline int bytestream2_seek_p(PutByteContext *p, int offset, int whence)
Definition: bytestream.h:236
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:225
CFHDEncContext::cb
Codebook cb[513]
Definition: cfhdenc.c:241
ImageHeight
@ ImageHeight
Definition: cfhd.h:49
BandTrailer
@ BandTrailer
Definition: cfhd.h:76
BandWidth
@ BandWidth
Definition: cfhd.h:69
CFHDEncContext::chroma_v_shift
int chroma_v_shift
Definition: cfhdenc.c:236
factor
static const int factor[16]
Definition: vf_pp7.c:76
SampleFlags
@ SampleFlags
Definition: cfhd.h:78
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
CFHDEncDSPContext
Definition: cfhdencdsp.h:25
flush_put_bits
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:143
NumLevels
@ NumLevels
Definition: cfhd.h:52
LowpassHeight
@ LowpassHeight
Definition: cfhd.h:54
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
alpha
static const int16_t alpha[]
Definition: ilbcdata.h:55
AVPacket
This structure stores compressed data.
Definition: packet.h:351
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:425
HighpassBorder
@ HighpassBorder
Definition: cfhd.h:65
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:571
bytestream.h
imgutils.h
CFHDEncContext::rb
Runbook rb[321]
Definition: cfhdenc.c:240
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
quantize_band
static void quantize_band(int16_t *input, int width, int a_width, int height, unsigned quantization)
Definition: cfhdenc.c:377
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
OFFSET
#define OFFSET(x)
Definition: cfhdenc.c:822
put_runcode
static int put_runcode(PutBitContext *pb, int count, const Runbook *const rb)
Definition: cfhdenc.c:389
put_bits.h
SampleIndexTable
@ SampleIndexTable
Definition: cfhd.h:33
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:234
ff_cfhd_encoder
const FFCodec ff_cfhd_encoder
Definition: cfhdenc.c:849
ff_alloc_packet
int ff_alloc_packet(AVCodecContext *avctx, AVPacket *avpkt, int64_t size)
Check AVPacket size and allocate data.
Definition: encode.c:35
CFHDEncContext::alpha
int16_t * alpha
Definition: cfhdenc.c:242
codebook
static const unsigned codebook[256][2]
Definition: cfhdenc.c:42
PixelOffset
@ PixelOffset
Definition: cfhd.h:55
Generated on Wed Sep 28 2022 19:21:12 for FFmpeg by   doxygen 1.8.17