2 * Copyright (c) 2020 Paul B Mahol
4 * This file is part of FFmpeg.
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.
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.
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
23 * Cineform HD video encoder
29 #include "libavutil/avassert.h"
30 #include "libavutil/imgutils.h"
31 #include "libavutil/opt.h"
34 #include "bytestream.h"
40 /* Derived from existing tables from decoder */
41 static const unsigned codebook[256][2] = {
42 { 1, 0x00000000 }, { 2, 0x00000002 }, { 3, 0x00000007 }, { 5, 0x00000019 }, { 6, 0x00000030 },
43 { 6, 0x00000036 }, { 7, 0x00000063 }, { 7, 0x0000006B }, { 7, 0x0000006F }, { 8, 0x000000D4 },
44 { 8, 0x000000DC }, { 9, 0x00000189 }, { 9, 0x000001A0 }, { 9, 0x000001AB }, {10, 0x00000310 },
45 {10, 0x00000316 }, {10, 0x00000354 }, {10, 0x00000375 }, {10, 0x00000377 }, {11, 0x00000623 },
46 {11, 0x00000684 }, {11, 0x000006AB }, {11, 0x000006EC }, {12, 0x00000C44 }, {12, 0x00000C5C },
47 {12, 0x00000C5E }, {12, 0x00000D55 }, {12, 0x00000DD1 }, {12, 0x00000DD3 }, {12, 0x00000DDB },
48 {13, 0x0000188B }, {13, 0x000018BB }, {13, 0x00001AA8 }, {13, 0x00001BA0 }, {13, 0x00001BA4 },
49 {13, 0x00001BB5 }, {14, 0x00003115 }, {14, 0x00003175 }, {14, 0x0000317D }, {14, 0x00003553 },
50 {14, 0x00003768 }, {15, 0x00006228 }, {15, 0x000062E8 }, {15, 0x000062F8 }, {15, 0x00006AA4 },
51 {15, 0x00006E85 }, {15, 0x00006E87 }, {15, 0x00006ED3 }, {16, 0x0000C453 }, {16, 0x0000C5D3 },
52 {16, 0x0000C5F3 }, {16, 0x0000DD08 }, {16, 0x0000DD0C }, {16, 0x0000DDA4 }, {17, 0x000188A4 },
53 {17, 0x00018BA5 }, {17, 0x00018BE5 }, {17, 0x0001AA95 }, {17, 0x0001AA97 }, {17, 0x0001BA13 },
54 {17, 0x0001BB4A }, {17, 0x0001BB4B }, {18, 0x00031748 }, {18, 0x000317C8 }, {18, 0x00035528 },
55 {18, 0x0003552C }, {18, 0x00037424 }, {18, 0x00037434 }, {18, 0x00037436 }, {19, 0x00062294 },
56 {19, 0x00062E92 }, {19, 0x00062F92 }, {19, 0x0006AA52 }, {19, 0x0006AA5A }, {19, 0x0006E84A },
57 {19, 0x0006E86A }, {19, 0x0006E86E }, {20, 0x000C452A }, {20, 0x000C5D27 }, {20, 0x000C5F26 },
58 {20, 0x000D54A6 }, {20, 0x000D54B6 }, {20, 0x000DD096 }, {20, 0x000DD0D6 }, {20, 0x000DD0DE },
59 {21, 0x00188A56 }, {21, 0x0018BA4D }, {21, 0x0018BE4E }, {21, 0x0018BE4F }, {21, 0x001AA96E },
60 {21, 0x001BA12E }, {21, 0x001BA12F }, {21, 0x001BA1AF }, {21, 0x001BA1BF }, {22, 0x00317498 },
61 {22, 0x0035529C }, {22, 0x0035529D }, {22, 0x003552DE }, {22, 0x003552DF }, {22, 0x0037435D },
62 {22, 0x0037437D }, {23, 0x0062295D }, {23, 0x0062E933 }, {23, 0x006AA53D }, {23, 0x006AA53E },
63 {23, 0x006AA53F }, {23, 0x006E86B9 }, {23, 0x006E86F8 }, {24, 0x00C452B8 }, {24, 0x00C5D265 },
64 {24, 0x00D54A78 }, {24, 0x00D54A79 }, {24, 0x00DD0D70 }, {24, 0x00DD0D71 }, {24, 0x00DD0DF2 },
65 {24, 0x00DD0DF3 }, {26, 0x03114BA2 }, {25, 0x0188A5B1 }, {25, 0x0188A58B }, {25, 0x0188A595 },
66 {25, 0x0188A5D6 }, {25, 0x0188A5D7 }, {25, 0x0188A5A8 }, {25, 0x0188A5AE }, {25, 0x0188A5AF },
67 {25, 0x0188A5C4 }, {25, 0x0188A5C5 }, {25, 0x0188A587 }, {25, 0x0188A584 }, {25, 0x0188A585 },
68 {25, 0x0188A5C6 }, {25, 0x0188A5C7 }, {25, 0x0188A5CC }, {25, 0x0188A5CD }, {25, 0x0188A581 },
69 {25, 0x0188A582 }, {25, 0x0188A583 }, {25, 0x0188A5CE }, {25, 0x0188A5CF }, {25, 0x0188A5C2 },
70 {25, 0x0188A5C3 }, {25, 0x0188A5C1 }, {25, 0x0188A5B4 }, {25, 0x0188A5B5 }, {25, 0x0188A5E6 },
71 {25, 0x0188A5E7 }, {25, 0x0188A5E4 }, {25, 0x0188A5E5 }, {25, 0x0188A5AB }, {25, 0x0188A5E0 },
72 {25, 0x0188A5E1 }, {25, 0x0188A5E2 }, {25, 0x0188A5E3 }, {25, 0x0188A5B6 }, {25, 0x0188A5B7 },
73 {25, 0x0188A5FD }, {25, 0x0188A57E }, {25, 0x0188A57F }, {25, 0x0188A5EC }, {25, 0x0188A5ED },
74 {25, 0x0188A5FE }, {25, 0x0188A5FF }, {25, 0x0188A57D }, {25, 0x0188A59C }, {25, 0x0188A59D },
75 {25, 0x0188A5E8 }, {25, 0x0188A5E9 }, {25, 0x0188A5EA }, {25, 0x0188A5EB }, {25, 0x0188A5EF },
76 {25, 0x0188A57A }, {25, 0x0188A57B }, {25, 0x0188A578 }, {25, 0x0188A579 }, {25, 0x0188A5BA },
77 {25, 0x0188A5BB }, {25, 0x0188A5B8 }, {25, 0x0188A5B9 }, {25, 0x0188A588 }, {25, 0x0188A589 },
78 {25, 0x018BA4C8 }, {25, 0x018BA4C9 }, {25, 0x0188A5FA }, {25, 0x0188A5FB }, {25, 0x0188A5BC },
79 {25, 0x0188A5BD }, {25, 0x0188A598 }, {25, 0x0188A599 }, {25, 0x0188A5F4 }, {25, 0x0188A5F5 },
80 {25, 0x0188A59B }, {25, 0x0188A5DE }, {25, 0x0188A5DF }, {25, 0x0188A596 }, {25, 0x0188A597 },
81 {25, 0x0188A5F8 }, {25, 0x0188A5F9 }, {25, 0x0188A5F1 }, {25, 0x0188A58E }, {25, 0x0188A58F },
82 {25, 0x0188A5DC }, {25, 0x0188A5DD }, {25, 0x0188A5F2 }, {25, 0x0188A5F3 }, {25, 0x0188A58C },
83 {25, 0x0188A58D }, {25, 0x0188A5A4 }, {25, 0x0188A5F0 }, {25, 0x0188A5A5 }, {25, 0x0188A5A6 },
84 {25, 0x0188A5A7 }, {25, 0x0188A59A }, {25, 0x0188A5A2 }, {25, 0x0188A5A3 }, {25, 0x0188A58A },
85 {25, 0x0188A5B0 }, {25, 0x0188A5A0 }, {25, 0x0188A5A1 }, {25, 0x0188A5DA }, {25, 0x0188A5DB },
86 {25, 0x0188A59E }, {25, 0x0188A59F }, {25, 0x0188A5D8 }, {25, 0x0188A5EE }, {25, 0x0188A5D9 },
87 {25, 0x0188A5F6 }, {25, 0x0188A5F7 }, {25, 0x0188A57C }, {25, 0x0188A5C8 }, {25, 0x0188A5C9 },
88 {25, 0x0188A594 }, {25, 0x0188A5FC }, {25, 0x0188A5CA }, {25, 0x0188A5CB }, {25, 0x0188A5B2 },
89 {25, 0x0188A5AA }, {25, 0x0188A5B3 }, {25, 0x0188A572 }, {25, 0x0188A573 }, {25, 0x0188A5C0 },
90 {25, 0x0188A5BE }, {25, 0x0188A5BF }, {25, 0x0188A592 }, {25, 0x0188A580 }, {25, 0x0188A593 },
91 {25, 0x0188A590 }, {25, 0x0188A591 }, {25, 0x0188A586 }, {25, 0x0188A5A9 }, {25, 0x0188A5D2 },
92 {25, 0x0188A5D3 }, {25, 0x0188A5D4 }, {25, 0x0188A5D5 }, {25, 0x0188A5AC }, {25, 0x0188A5AD },
96 /* Derived by extracting runcodes from existing tables from decoder */
97 static const uint16_t runbook[8][3] = {
98 {1, 0x0000, 1}, {7, 0x0069, 12}, {8, 0x00D1, 20}, {9, 0x018A, 32},
99 {10, 0x0343, 60}, {11, 0x0685, 100}, {13, 0x18BF, 180}, {13, 0x1BA5, 320},
103 * Derived by inspecting various quality encodes
104 * and adding some more from scratch.
106 static const uint16_t quantization_per_subband[2][3][13][9] = {
108 { 16, 16, 8, 4, 4, 2, 3, 3, 4, }, // film3+
109 { 16, 16, 8, 4, 4, 2, 3, 3, 4, }, // film3
110 { 16, 16, 8, 4, 4, 2, 4, 4, 6, }, // film2+
111 { 16, 16, 8, 4, 4, 2, 4, 4, 6, }, // film2
112 { 16, 16, 8, 4, 4, 2, 8, 8, 12, }, // film1++
113 { 24, 24, 12, 6, 6, 3, 12, 12, 18, }, // film1+
114 { 24, 24, 12, 6, 6, 3, 12, 12, 18, }, // film1
115 { 32, 32, 24, 8, 8, 6, 16, 16, 24, }, // high+
116 { 32, 32, 24, 8, 8, 6, 16, 16, 24, }, // high
117 { 48, 48, 32, 12, 12, 8, 32, 32, 48, }, // medium+
118 { 48, 48, 32, 12, 12, 8, 32, 32, 48, }, // medium
119 { 64, 64, 48, 16, 16, 12, 48, 48, 64, }, // low+
120 { 64, 64, 48, 16, 16, 12, 64, 64, 96, }, // low
123 { 16, 16, 8, 4, 4, 2, 3, 3, 4, },
124 { 16, 16, 8, 4, 4, 2, 3, 3, 6, },
125 { 16, 16, 8, 4, 4, 2, 4, 4, 6, },
126 { 16, 16, 8, 4, 4, 2, 4, 4, 8, },
127 { 16, 16, 8, 4, 4, 2, 8, 8, 16, },
128 { 24, 24, 12, 6, 6, 3, 12, 12, 18, },
129 { 24, 24, 12, 6, 6, 3, 12, 12, 24, },
130 { 32, 32, 24, 8, 8, 6, 16, 16, 24, },
131 { 48, 48, 32, 12, 12, 8, 16, 16, 32, },
132 { 48, 48, 32, 12, 12, 8, 32, 32, 48, },
133 { 48, 48, 32, 12, 12, 8, 32, 32, 64, },
134 { 64, 64, 48, 16, 16, 12, 48, 48, 64, },
135 { 64, 64, 48, 16, 16, 12, 64, 64, 96, },
138 { 16, 16, 8, 4, 4, 2, 3, 3, 4, },
139 { 16, 16, 8, 4, 4, 2, 3, 3, 6, },
140 { 16, 16, 8, 4, 4, 2, 4, 4, 6, },
141 { 16, 16, 8, 4, 4, 2, 4, 4, 8, },
142 { 16, 16, 8, 4, 4, 2, 8, 8, 16, },
143 { 24, 24, 12, 6, 6, 3, 12, 12, 18, },
144 { 24, 24, 12, 6, 6, 3, 12, 12, 24, },
145 { 32, 32, 24, 8, 8, 6, 16, 16, 24, },
146 { 48, 48, 32, 12, 12, 8, 16, 16, 32, },
147 { 48, 48, 32, 12, 12, 8, 32, 32, 48, },
148 { 48, 48, 32, 12, 12, 8, 32, 32, 64, },
149 { 64, 64, 48, 16, 16, 12, 48, 48, 64, },
150 { 64, 64, 48, 16, 16, 12, 64, 64, 96, },
153 { 16, 16, 8, 16, 16, 8, 24, 24, 36, },
154 { 16, 16, 8, 16, 16, 8, 32, 32, 48, },
155 { 16, 16, 8, 16, 16, 8, 48, 48, 72, },
156 { 16, 16, 8, 16, 16, 8, 64, 64, 96, },
157 { 16, 16, 8, 20, 20, 10, 80, 80, 128, },
158 { 24, 24, 12, 24, 24, 12, 96, 96, 144, },
159 { 24, 24, 12, 24, 24, 12, 128, 128, 192, },
160 { 32, 32, 24, 32, 32, 24, 192, 192, 288, },
161 { 32, 32, 24, 32, 32, 24, 256, 256, 384, },
162 { 48, 48, 32, 48, 48, 32, 256, 256, 384, },
163 { 48, 48, 32, 48, 48, 32, 512, 512, 768, },
164 { 56, 56, 40, 56, 56, 40, 512, 512, 768, },
165 { 64, 64, 48, 64, 64, 48, 512, 512, 768, },
168 { 16, 16, 8, 16, 16, 8, 24, 24, 36, },
169 { 16, 16, 8, 16, 16, 8, 32, 32, 48, },
170 { 16, 16, 8, 16, 16, 8, 48, 48, 72, },
171 { 16, 16, 8, 16, 16, 8, 64, 64, 96, },
172 { 16, 16, 8, 20, 20, 10, 80, 80, 128, },
173 { 24, 24, 12, 24, 24, 12, 96, 96, 144, },
174 { 24, 24, 12, 24, 24, 12, 128, 128, 192, },
175 { 32, 32, 24, 32, 32, 24, 192, 192, 288, },
176 { 32, 32, 24, 32, 32, 24, 256, 256, 384, },
177 { 48, 48, 32, 48, 48, 32, 256, 256, 384, },
178 { 48, 48, 32, 48, 48, 32, 512, 512, 768, },
179 { 56, 56, 40, 56, 56, 40, 512, 512, 768, },
180 { 64, 64, 48, 64, 64, 48, 512, 512, 768, },
183 { 16, 16, 8, 16, 16, 8, 24, 24, 36, },
184 { 16, 16, 8, 16, 16, 8, 32, 32, 48, },
185 { 16, 16, 8, 16, 16, 8, 48, 48, 72, },
186 { 16, 16, 8, 16, 16, 8, 64, 64, 96, },
187 { 16, 16, 10, 20, 20, 10, 80, 80, 128, },
188 { 24, 24, 12, 24, 24, 12, 96, 96, 144, },
189 { 24, 24, 12, 24, 24, 12, 128, 128, 192, },
190 { 32, 32, 24, 32, 32, 24, 192, 192, 288, },
191 { 32, 32, 24, 32, 32, 24, 256, 256, 384, },
192 { 48, 48, 32, 48, 48, 32, 256, 256, 384, },
193 { 48, 48, 32, 48, 48, 32, 512, 512, 768, },
194 { 56, 56, 40, 56, 56, 40, 512, 512, 768, },
195 { 64, 64, 48, 64, 64, 48, 512, 512, 768, },
199 typedef struct Codebook {
204 typedef struct Runbook {
210 typedef struct PlaneEnc {
216 unsigned quantization[SUBBAND_COUNT];
217 int16_t *subband[SUBBAND_COUNT];
220 SubBand band[DWT_LEVELS][4];
223 typedef struct CFHDEncContext {
224 const AVClass *class;
240 static av_cold int cfhd_encode_init(AVCodecContext *avctx)
242 CFHDEncContext *s = avctx->priv_data;
243 const int sign_mask = 256;
244 const int twos_complement = -sign_mask;
245 const int mag_mask = sign_mask - 1;
248 ret = av_pix_fmt_get_chroma_sub_sample(avctx->pix_fmt,
254 if (avctx->width & 15) {
255 av_log(avctx, AV_LOG_ERROR, "Width must be multiple of 16.\n");
256 return AVERROR_INVALIDDATA;
259 s->planes = av_pix_fmt_count_planes(avctx->pix_fmt);
261 for (int i = 0; i < s->planes; i++) {
262 int w8, h8, w4, h4, w2, h2;
263 int width = i ? avctx->width >> s->chroma_h_shift : avctx->width;
264 int height = i ? FFALIGN(avctx->height >> s->chroma_v_shift, 8) :
265 FFALIGN(avctx->height >> s->chroma_v_shift, 8);
266 ptrdiff_t stride = FFALIGN(width / 8, 8) * 8;
268 w8 = FFALIGN(width / 8, 8);
275 s->plane[i].dwt_buf =
276 av_mallocz_array(height * stride, sizeof(*s->plane[i].dwt_buf));
277 s->plane[i].dwt_tmp =
278 av_malloc_array(height * stride, sizeof(*s->plane[i].dwt_tmp));
279 if (!s->plane[i].dwt_buf || !s->plane[i].dwt_tmp)
280 return AVERROR(ENOMEM);
282 s->plane[i].subband[0] = s->plane[i].dwt_buf;
283 s->plane[i].subband[1] = s->plane[i].dwt_buf + 2 * w8 * h8;
284 s->plane[i].subband[2] = s->plane[i].dwt_buf + 1 * w8 * h8;
285 s->plane[i].subband[3] = s->plane[i].dwt_buf + 3 * w8 * h8;
286 s->plane[i].subband[4] = s->plane[i].dwt_buf + 2 * w4 * h4;
287 s->plane[i].subband[5] = s->plane[i].dwt_buf + 1 * w4 * h4;
288 s->plane[i].subband[6] = s->plane[i].dwt_buf + 3 * w4 * h4;
289 s->plane[i].subband[7] = s->plane[i].dwt_buf + 2 * w2 * h2;
290 s->plane[i].subband[8] = s->plane[i].dwt_buf + 1 * w2 * h2;
291 s->plane[i].subband[9] = s->plane[i].dwt_buf + 3 * w2 * h2;
293 for (int j = 0; j < DWT_LEVELS; j++) {
294 for (int k = 0; k < FF_ARRAY_ELEMS(s->plane[i].band[j]); k++) {
295 s->plane[i].band[j][k].width = (width / 8) << j;
296 s->plane[i].band[j][k].height = (height / 8) << j;
297 s->plane[i].band[j][k].a_width = w8 << j;
298 s->plane[i].band[j][k].a_height = h8 << j;
302 /* ll2 and ll1 commented out because they are done in-place */
303 s->plane[i].l_h[0] = s->plane[i].dwt_tmp;
304 s->plane[i].l_h[1] = s->plane[i].dwt_tmp + 2 * w8 * h8;
305 // s->plane[i].l_h[2] = ll2;
306 s->plane[i].l_h[3] = s->plane[i].dwt_tmp;
307 s->plane[i].l_h[4] = s->plane[i].dwt_tmp + 2 * w4 * h4;
308 // s->plane[i].l_h[5] = ll1;
309 s->plane[i].l_h[6] = s->plane[i].dwt_tmp;
310 s->plane[i].l_h[7] = s->plane[i].dwt_tmp + 2 * w2 * h2;
313 for (int i = 0; i < 512; i++) {
314 int value = (i & sign_mask) ? twos_complement + (i & mag_mask): i;
315 int mag = FFMIN(FFABS(value), 255);
318 s->cb[i].bits = (codebook[mag][1] << 1) | (value > 0 ? 0 : 1);
319 s->cb[i].size = codebook[mag][0] + 1;
321 s->cb[i].bits = codebook[mag][1];
322 s->cb[i].size = codebook[mag][0];
326 s->cb[512].bits = 0x3114ba3;
327 s->cb[512].size = 26;
331 for (int i = 1, j = 0; i < 320 && j < 7; j++) {
332 int run = runbook[j][2];
333 int end = runbook[j+1][2];
337 s->rb[i].bits = runbook[j][1];
338 s->rb[i++].size = runbook[j][0];
342 s->rb[320].bits = runbook[7][1];
343 s->rb[320].size = runbook[7][0];
344 s->rb[320].run = 320;
346 for (int i = 0; i < 256; i++) {
347 int idx = i + ((768LL * i * i * i) / (256 * 256 * 256));
351 for (int i = 0; i < 1024; i++) {
361 static inline void filter(int16_t *input, ptrdiff_t in_stride,
362 int16_t *low, ptrdiff_t low_stride,
363 int16_t *high, ptrdiff_t high_stride,
366 low[(0>>1) * low_stride] = av_clip_int16(input[0*in_stride] + input[1*in_stride]);
367 high[(0>>1) * high_stride] = av_clip_int16((5 * input[0*in_stride] - 11 * input[1*in_stride] +
368 4 * input[2*in_stride] + 4 * input[3*in_stride] -
369 1 * input[4*in_stride] - 1 * input[5*in_stride] + 4) >> 3);
371 for (int i = 2; i < len - 2; i += 2) {
372 low[(i>>1) * low_stride] = av_clip_int16(input[i*in_stride] + input[(i+1)*in_stride]);
373 high[(i>>1) * high_stride] = av_clip_int16(((-input[(i-2)*in_stride] - input[(i-1)*in_stride] +
374 input[(i+2)*in_stride] + input[(i+3)*in_stride] + 4) >> 3) +
375 input[(i+0)*in_stride] - input[(i+1)*in_stride]);
378 low[((len-2)>>1) * low_stride] = av_clip_int16(input[((len-2)+0)*in_stride] + input[((len-2)+1)*in_stride]);
379 high[((len-2)>>1) * high_stride] = av_clip_int16((11* input[((len-2)+0)*in_stride] - 5 * input[((len-2)+1)*in_stride] -
380 4 * input[((len-2)-1)*in_stride] - 4 * input[((len-2)-2)*in_stride] +
381 1 * input[((len-2)-3)*in_stride] + 1 * input[((len-2)-4)*in_stride] + 4) >> 3);
384 static void horiz_filter(int16_t *input, int16_t *low, int16_t *high,
387 filter(input, 1, low, 1, high, 1, width);
390 static void vert_filter(int16_t *input, ptrdiff_t in_stride,
391 int16_t *low, ptrdiff_t low_stride,
392 int16_t *high, ptrdiff_t high_stride, int len)
394 filter(input, in_stride, low, low_stride, high, high_stride, len);
397 static void quantize_band(int16_t *input, int width, int a_width,
398 int height, unsigned quantization)
400 const int factor = (1 << 16) / quantization;
402 for (int i = 0; i < height; i++) {
403 for (int j = 0; j < width; j++)
404 input[j] = av_clip_intp2((input[j] * factor) / 65536, 10);
409 static int put_runcode(PutBitContext *pb, int count, const Runbook *const rb)
412 const int index = FFMIN(320, count);
414 put_bits(pb, rb[index].size, rb[index].bits);
415 count -= rb[index].run;
421 static int cfhd_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
422 const AVFrame *frame, int *got_packet)
424 CFHDEncContext *s = avctx->priv_data;
425 PutByteContext *pby = &s->pby;
426 PutBitContext *pb = &s->pb;
427 const Codebook *const cb = s->cb;
428 const Runbook *const rb = s->rb;
429 const uint16_t *lut = s->lut;
433 for (int plane = 0; plane < s->planes && !ret; plane++) {
434 int width = s->plane[plane].band[2][0].width;
435 int a_width = s->plane[plane].band[2][0].a_width;
436 int height = s->plane[plane].band[2][0].height;
437 int act_plane = plane == 1 ? 2 : plane == 2 ? 1 : plane;
438 int16_t *input = (int16_t *)frame->data[act_plane];
439 int16_t *low = s->plane[plane].l_h[6];
440 int16_t *high = s->plane[plane].l_h[7];
441 const ptrdiff_t in_stride = frame->linesize[act_plane] / 2;
442 int low_stride, high_stride;
444 for (int i = 0; i < height * 2; i++) {
445 horiz_filter(input, low, high, width * 2);
451 input = s->plane[plane].l_h[7];
452 low = s->plane[plane].subband[7];
453 low_stride = s->plane[plane].band[2][0].a_width;
454 high = s->plane[plane].subband[9];
455 high_stride = s->plane[plane].band[2][0].a_width;
457 for (int i = 0; i < width; i++) {
458 vert_filter(input, a_width, low, low_stride, high, high_stride, height * 2);
464 input = s->plane[plane].l_h[6];
465 low = s->plane[plane].l_h[7];
466 high = s->plane[plane].subband[8];
468 for (int i = 0; i < width; i++) {
469 vert_filter(input, a_width, low, low_stride, high, high_stride, height * 2);
475 a_width = s->plane[plane].band[1][0].a_width;
476 width = s->plane[plane].band[1][0].width;
477 height = s->plane[plane].band[1][0].height;
478 input = s->plane[plane].l_h[7];
479 low = s->plane[plane].l_h[3];
480 low_stride = s->plane[plane].band[1][0].a_width;
481 high = s->plane[plane].l_h[4];
482 high_stride = s->plane[plane].band[1][0].a_width;
484 for (int i = 0; i < height * 2; i++) {
485 for (int j = 0; j < width * 2; j++)
487 input += a_width * 2;
490 input = s->plane[plane].l_h[7];
491 for (int i = 0; i < height * 2; i++) {
492 horiz_filter(input, low, high, width * 2);
493 input += a_width * 2;
498 input = s->plane[plane].l_h[4];
499 low = s->plane[plane].subband[4];
500 high = s->plane[plane].subband[6];
502 for (int i = 0; i < width; i++) {
503 vert_filter(input, a_width, low, low_stride, high, high_stride, height * 2);
509 input = s->plane[plane].l_h[3];
510 low = s->plane[plane].l_h[4];
511 high = s->plane[plane].subband[5];
513 for (int i = 0; i < width; i++) {
514 vert_filter(input, a_width, low, low_stride, high, high_stride, height * 2);
520 a_width = s->plane[plane].band[0][0].a_width;
521 width = s->plane[plane].band[0][0].width;
522 height = s->plane[plane].band[0][0].height;
523 input = s->plane[plane].l_h[4];
524 low = s->plane[plane].l_h[0];
525 low_stride = s->plane[plane].band[0][0].a_width;
526 high = s->plane[plane].l_h[1];
527 high_stride = s->plane[plane].band[0][0].a_width;
529 if (avctx->pix_fmt != AV_PIX_FMT_YUV422P10) {
530 for (int i = 0; i < height * 2; i++) {
531 for (int j = 0; j < width * 2; j++)
533 input += a_width * 2;
537 input = s->plane[plane].l_h[4];
538 for (int i = 0; i < height * 2; i++) {
539 horiz_filter(input, low, high, width * 2);
540 input += a_width * 2;
545 low = s->plane[plane].subband[1];
546 high = s->plane[plane].subband[3];
547 input = s->plane[plane].l_h[1];
549 for (int i = 0; i < width; i++) {
550 vert_filter(input, a_width, low, low_stride, high, high_stride, height * 2);
556 low = s->plane[plane].subband[0];
557 high = s->plane[plane].subband[2];
558 input = s->plane[plane].l_h[0];
560 for (int i = 0; i < width; i++) {
561 vert_filter(input, a_width, low, low_stride, high, high_stride, height * 2);
568 ret = ff_alloc_packet2(avctx, pkt, 64LL + s->planes * (2LL * avctx->width * avctx->height + 1000LL), 0);
572 bytestream2_init_writer(pby, pkt->data, pkt->size);
574 bytestream2_put_be16(pby, SampleType);
575 bytestream2_put_be16(pby, 9);
577 bytestream2_put_be16(pby, SampleIndexTable);
578 bytestream2_put_be16(pby, s->planes);
580 for (int i = 0; i < s->planes; i++)
581 bytestream2_put_be32(pby, 0);
583 bytestream2_put_be16(pby, TransformType);
584 bytestream2_put_be16(pby, 0);
586 bytestream2_put_be16(pby, NumFrames);
587 bytestream2_put_be16(pby, 1);
589 bytestream2_put_be16(pby, ChannelCount);
590 bytestream2_put_be16(pby, s->planes);
592 bytestream2_put_be16(pby, EncodedFormat);
593 bytestream2_put_be16(pby, avctx->pix_fmt == AV_PIX_FMT_YUV422P10 ? 1 : 3);
595 bytestream2_put_be16(pby, WaveletCount);
596 bytestream2_put_be16(pby, 3);
598 bytestream2_put_be16(pby, SubbandCount);
599 bytestream2_put_be16(pby, SUBBAND_COUNT);
601 bytestream2_put_be16(pby, NumSpatial);
602 bytestream2_put_be16(pby, 2);
604 bytestream2_put_be16(pby, FirstWavelet);
605 bytestream2_put_be16(pby, 3);
607 bytestream2_put_be16(pby, ImageWidth);
608 bytestream2_put_be16(pby, avctx->width);
610 bytestream2_put_be16(pby, ImageHeight);
611 bytestream2_put_be16(pby, avctx->height);
613 bytestream2_put_be16(pby, -FrameNumber);
614 bytestream2_put_be16(pby, avctx->frame_number);
616 bytestream2_put_be16(pby, Precision);
617 bytestream2_put_be16(pby, avctx->pix_fmt == AV_PIX_FMT_YUV422P10 ? 10 : 12);
619 bytestream2_put_be16(pby, PrescaleTable);
620 bytestream2_put_be16(pby, avctx->pix_fmt == AV_PIX_FMT_YUV422P10 ? 0x2000 : 0x2800);
622 bytestream2_put_be16(pby, SampleFlags);
623 bytestream2_put_be16(pby, 1);
625 for (int p = 0; p < s->planes; p++) {
626 int width = s->plane[p].band[0][0].width;
627 int a_width = s->plane[p].band[0][0].a_width;
628 int height = s->plane[p].band[0][0].height;
629 int16_t *data = s->plane[p].subband[0];
632 bytestream2_put_be16(pby, SampleType);
633 bytestream2_put_be16(pby, 3);
635 bytestream2_put_be16(pby, ChannelNumber);
636 bytestream2_put_be16(pby, p);
639 bytestream2_put_be16(pby, BitstreamMarker);
640 bytestream2_put_be16(pby, 0x1a4a);
642 pos = bytestream2_tell_p(pby);
644 bytestream2_put_be16(pby, LowpassSubband);
645 bytestream2_put_be16(pby, 0);
647 bytestream2_put_be16(pby, NumLevels);
648 bytestream2_put_be16(pby, 3);
650 bytestream2_put_be16(pby, LowpassWidth);
651 bytestream2_put_be16(pby, width);
653 bytestream2_put_be16(pby, LowpassHeight);
654 bytestream2_put_be16(pby, height);
656 bytestream2_put_be16(pby, PixelOffset);
657 bytestream2_put_be16(pby, 0);
659 bytestream2_put_be16(pby, LowpassQuantization);
660 bytestream2_put_be16(pby, 1);
662 bytestream2_put_be16(pby, LowpassPrecision);
663 bytestream2_put_be16(pby, 16);
665 bytestream2_put_be16(pby, BitstreamMarker);
666 bytestream2_put_be16(pby, 0x0f0f);
668 for (int i = 0; i < height; i++) {
669 for (int j = 0; j < width; j++)
670 bytestream2_put_be16(pby, data[j]);
674 bytestream2_put_be16(pby, BitstreamMarker);
675 bytestream2_put_be16(pby, 0x1b4b);
677 for (int l = 0; l < 3; l++) {
678 for (int i = 0; i < 3; i++) {
679 s->plane[p].quantization[1 + l * 3 + i] = quantization_per_subband[avctx->pix_fmt != AV_PIX_FMT_YUV422P10][p][s->quality][l * 3 + i];
683 for (int l = 0; l < 3; l++) {
684 int a_width = s->plane[p].band[l][0].a_width;
685 int width = s->plane[p].band[l][0].width;
686 int stride = FFALIGN(width, 8);
687 int height = s->plane[p].band[l][0].height;
689 bytestream2_put_be16(pby, BitstreamMarker);
690 bytestream2_put_be16(pby, 0x0d0d);
692 bytestream2_put_be16(pby, WaveletType);
693 bytestream2_put_be16(pby, 3 + 2 * (l == 2));
695 bytestream2_put_be16(pby, WaveletNumber);
696 bytestream2_put_be16(pby, 3 - l);
698 bytestream2_put_be16(pby, WaveletLevel);
699 bytestream2_put_be16(pby, 3 - l);
701 bytestream2_put_be16(pby, NumBands);
702 bytestream2_put_be16(pby, 4);
704 bytestream2_put_be16(pby, HighpassWidth);
705 bytestream2_put_be16(pby, width);
707 bytestream2_put_be16(pby, HighpassHeight);
708 bytestream2_put_be16(pby, height);
710 bytestream2_put_be16(pby, LowpassBorder);
711 bytestream2_put_be16(pby, 0);
713 bytestream2_put_be16(pby, HighpassBorder);
714 bytestream2_put_be16(pby, 0);
716 bytestream2_put_be16(pby, LowpassScale);
717 bytestream2_put_be16(pby, 1);
719 bytestream2_put_be16(pby, LowpassDivisor);
720 bytestream2_put_be16(pby, 1);
722 for (int i = 0; i < 3; i++) {
723 int16_t *data = s->plane[p].subband[1 + l * 3 + i];
724 int count = 0, padd = 0;
726 bytestream2_put_be16(pby, BitstreamMarker);
727 bytestream2_put_be16(pby, 0x0e0e);
729 bytestream2_put_be16(pby, SubbandNumber);
730 bytestream2_put_be16(pby, i + 1);
732 bytestream2_put_be16(pby, BandCodingFlags);
733 bytestream2_put_be16(pby, 1);
735 bytestream2_put_be16(pby, BandWidth);
736 bytestream2_put_be16(pby, width);
738 bytestream2_put_be16(pby, BandHeight);
739 bytestream2_put_be16(pby, height);
741 bytestream2_put_be16(pby, SubbandBand);
742 bytestream2_put_be16(pby, 1 + l * 3 + i);
744 bytestream2_put_be16(pby, BandEncoding);
745 bytestream2_put_be16(pby, 3);
747 bytestream2_put_be16(pby, Quantization);
748 bytestream2_put_be16(pby, s->plane[p].quantization[1 + l * 3 + i]);
750 bytestream2_put_be16(pby, BandScale);
751 bytestream2_put_be16(pby, 1);
753 bytestream2_put_be16(pby, BandHeader);
754 bytestream2_put_be16(pby, 0);
756 quantize_band(data, width, a_width, height,
757 s->plane[p].quantization[1 + l * 3 + i]);
759 init_put_bits(pb, pkt->data + bytestream2_tell_p(pby), bytestream2_get_bytes_left_p(pby));
761 for (int m = 0; m < height; m++) {
762 for (int j = 0; j < stride; j++) {
763 int16_t index = FFSIGN(data[j]) * lut[FFABS(data[j])];
770 } else if (count > 0) {
771 count = put_runcode(pb, count, rb);
774 put_bits(pb, cb[index].size, cb[index].bits);
781 count = put_runcode(pb, count, rb);
784 put_bits(pb, cb[512].size, cb[512].bits);
787 bytestream2_skip_p(pby, put_bits_count(pb) >> 3);
788 padd = (4 - (bytestream2_tell_p(pby) & 3)) & 3;
790 bytestream2_put_byte(pby, 0);
792 bytestream2_put_be16(pby, BandTrailer);
793 bytestream2_put_be16(pby, 0);
796 bytestream2_put_be16(pby, BitstreamMarker);
797 bytestream2_put_be16(pby, 0x0c0c);
800 s->plane[p].size = bytestream2_tell_p(pby) - pos;
803 bytestream2_put_be16(pby, GroupTrailer);
804 bytestream2_put_be16(pby, 0);
806 av_shrink_packet(pkt, bytestream2_tell_p(pby));
808 pkt->flags |= AV_PKT_FLAG_KEY;
810 bytestream2_seek_p(pby, 8, SEEK_SET);
811 for (int i = 0; i < s->planes; i++)
812 bytestream2_put_be32(pby, s->plane[i].size);
819 static av_cold int cfhd_encode_close(AVCodecContext *avctx)
821 CFHDEncContext *s = avctx->priv_data;
823 for (int i = 0; i < s->planes; i++) {
824 av_freep(&s->plane[i].dwt_buf);
825 av_freep(&s->plane[i].dwt_tmp);
827 for (int j = 0; j < SUBBAND_COUNT; j++)
828 s->plane[i].subband[j] = NULL;
830 for (int j = 0; j < 8; j++)
831 s->plane[i].l_h[j] = NULL;
837 #define OFFSET(x) offsetof(CFHDEncContext, x)
838 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
839 static const AVOption options[] = {
840 { "quality", "set quality", OFFSET(quality), AV_OPT_TYPE_INT, {.i64= 0}, 0, 12, VE, "q" },
841 { "film3+", NULL, 0, AV_OPT_TYPE_CONST, {.i64= 0}, 0, 0, VE, "q" },
842 { "film3", NULL, 0, AV_OPT_TYPE_CONST, {.i64= 1}, 0, 0, VE, "q" },
843 { "film2+", NULL, 0, AV_OPT_TYPE_CONST, {.i64= 2}, 0, 0, VE, "q" },
844 { "film2", NULL, 0, AV_OPT_TYPE_CONST, {.i64= 3}, 0, 0, VE, "q" },
845 { "film1.5", NULL, 0, AV_OPT_TYPE_CONST, {.i64= 4}, 0, 0, VE, "q" },
846 { "film1+", NULL, 0, AV_OPT_TYPE_CONST, {.i64= 5}, 0, 0, VE, "q" },
847 { "film1", NULL, 0, AV_OPT_TYPE_CONST, {.i64= 6}, 0, 0, VE, "q" },
848 { "high+", NULL, 0, AV_OPT_TYPE_CONST, {.i64= 7}, 0, 0, VE, "q" },
849 { "high", NULL, 0, AV_OPT_TYPE_CONST, {.i64= 8}, 0, 0, VE, "q" },
850 { "medium+", NULL, 0, AV_OPT_TYPE_CONST, {.i64= 9}, 0, 0, VE, "q" },
851 { "medium", NULL, 0, AV_OPT_TYPE_CONST, {.i64=10}, 0, 0, VE, "q" },
852 { "low+", NULL, 0, AV_OPT_TYPE_CONST, {.i64=11}, 0, 0, VE, "q" },
853 { "low", NULL, 0, AV_OPT_TYPE_CONST, {.i64=12}, 0, 0, VE, "q" },
857 static const AVClass cfhd_class = {
858 .class_name = "cfhd",
859 .item_name = av_default_item_name,
861 .version = LIBAVUTIL_VERSION_INT,
864 AVCodec ff_cfhd_encoder = {
866 .long_name = NULL_IF_CONFIG_SMALL("Cineform HD"),
867 .type = AVMEDIA_TYPE_VIDEO,
868 .id = AV_CODEC_ID_CFHD,
869 .priv_data_size = sizeof(CFHDEncContext),
870 .priv_class = &cfhd_class,
871 .init = cfhd_encode_init,
872 .close = cfhd_encode_close,
873 .encode2 = cfhd_encode_frame,
874 .capabilities = AV_CODEC_CAP_FRAME_THREADS,
875 .pix_fmts = (const enum AVPixelFormat[]) {
876 AV_PIX_FMT_YUV422P10,