avcodec: add CFHD encoder

1 files changed, 760 insertions, 0 deletions

diff --git a/libavcodec/cfhdenc.c b/libavcodec/cfhdenc.c
new file mode 100644
index 0000000000..22fc23285e
--- /dev/null
+++ b/libavcodec/cfhdenc.c
@@ -0,0 +1,760 @@
+/*
+ * Copyright (c) 2020 Paul B Mahol
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+/**
+ * @file
+ * Cineform HD video encoder
+ */
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "libavutil/avassert.h"
+#include "libavutil/imgutils.h"
+#include "libavutil/opt.h"
+
+#include "avcodec.h"
+#include "bytestream.h"
+#include "cfhd.h"
+#include "put_bits.h"
+#include "internal.h"
+#include "thread.h"
+
+/* Derived from existing tables from decoder */
+static const unsigned codebook[256][2] = {
+    { 1, 0x00000000 }, { 2, 0x00000002 }, { 3, 0x00000007 }, { 5, 0x00000019 }, { 6, 0x00000030 },
+    { 6, 0x00000036 }, { 7, 0x00000063 }, { 7, 0x0000006B }, { 7, 0x0000006F }, { 8, 0x000000D4 },
+    { 8, 0x000000DC }, { 9, 0x00000189 }, { 9, 0x000001A0 }, { 9, 0x000001AB }, {10, 0x00000310 },
+    {10, 0x00000316 }, {10, 0x00000354 }, {10, 0x00000375 }, {10, 0x00000377 }, {11, 0x00000623 },
+    {11, 0x00000684 }, {11, 0x000006AB }, {11, 0x000006EC }, {12, 0x00000C44 }, {12, 0x00000C5C },
+    {12, 0x00000C5E }, {12, 0x00000D55 }, {12, 0x00000DD1 }, {12, 0x00000DD3 }, {12, 0x00000DDB },
+    {13, 0x0000188B }, {13, 0x000018BB }, {13, 0x00001AA8 }, {13, 0x00001BA0 }, {13, 0x00001BA4 },
+    {13, 0x00001BB5 }, {14, 0x00003115 }, {14, 0x00003175 }, {14, 0x0000317D }, {14, 0x00003553 },
+    {14, 0x00003768 }, {15, 0x00006228 }, {15, 0x000062E8 }, {15, 0x000062F8 }, {15, 0x00006AA4 },
+    {15, 0x00006E85 }, {15, 0x00006E87 }, {15, 0x00006ED3 }, {16, 0x0000C453 }, {16, 0x0000C5D3 },
+    {16, 0x0000C5F3 }, {16, 0x0000DD08 }, {16, 0x0000DD0C }, {16, 0x0000DDA4 }, {17, 0x000188A4 },
+    {17, 0x00018BA5 }, {17, 0x00018BE5 }, {17, 0x0001AA95 }, {17, 0x0001AA97 }, {17, 0x0001BA13 },
+    {17, 0x0001BB4A }, {17, 0x0001BB4B }, {18, 0x00031748 }, {18, 0x000317C8 }, {18, 0x00035528 },
+    {18, 0x0003552C }, {18, 0x00037424 }, {18, 0x00037434 }, {18, 0x00037436 }, {19, 0x00062294 },
+    {19, 0x00062E92 }, {19, 0x00062F92 }, {19, 0x0006AA52 }, {19, 0x0006AA5A }, {19, 0x0006E84A },
+    {19, 0x0006E86A }, {19, 0x0006E86E }, {20, 0x000C452A }, {20, 0x000C5D27 }, {20, 0x000C5F26 },
+    {20, 0x000D54A6 }, {20, 0x000D54B6 }, {20, 0x000DD096 }, {20, 0x000DD0D6 }, {20, 0x000DD0DE },
+    {21, 0x00188A56 }, {21, 0x0018BA4D }, {21, 0x0018BE4E }, {21, 0x0018BE4F }, {21, 0x001AA96E },
+    {21, 0x001BA12E }, {21, 0x001BA12F }, {21, 0x001BA1AF }, {21, 0x001BA1BF }, {22, 0x00317498 },
+    {22, 0x0035529C }, {22, 0x0035529D }, {22, 0x003552DE }, {22, 0x003552DF }, {22, 0x0037435D },
+    {22, 0x0037437D }, {23, 0x0062295D }, {23, 0x0062E933 }, {23, 0x006AA53D }, {23, 0x006AA53E },
+    {23, 0x006AA53F }, {23, 0x006E86B9 }, {23, 0x006E86F8 }, {24, 0x00C452B8 }, {24, 0x00C5D265 },
+    {24, 0x00D54A78 }, {24, 0x00D54A79 }, {24, 0x00DD0D70 }, {24, 0x00DD0D71 }, {24, 0x00DD0DF2 },
+    {24, 0x00DD0DF3 }, {26, 0x03114BA2 }, {25, 0x0188A5B1 }, {25, 0x0188A58B }, {25, 0x0188A595 },
+    {25, 0x0188A5D6 }, {25, 0x0188A5D7 }, {25, 0x0188A5A8 }, {25, 0x0188A5AE }, {25, 0x0188A5AF },
+    {25, 0x0188A5C4 }, {25, 0x0188A5C5 }, {25, 0x0188A587 }, {25, 0x0188A584 }, {25, 0x0188A585 },
+    {25, 0x0188A5C6 }, {25, 0x0188A5C7 }, {25, 0x0188A5CC }, {25, 0x0188A5CD }, {25, 0x0188A581 },
+    {25, 0x0188A582 }, {25, 0x0188A583 }, {25, 0x0188A5CE }, {25, 0x0188A5CF }, {25, 0x0188A5C2 },
+    {25, 0x0188A5C3 }, {25, 0x0188A5C1 }, {25, 0x0188A5B4 }, {25, 0x0188A5B5 }, {25, 0x0188A5E6 },
+    {25, 0x0188A5E7 }, {25, 0x0188A5E4 }, {25, 0x0188A5E5 }, {25, 0x0188A5AB }, {25, 0x0188A5E0 },
+    {25, 0x0188A5E1 }, {25, 0x0188A5E2 }, {25, 0x0188A5E3 }, {25, 0x0188A5B6 }, {25, 0x0188A5B7 },
+    {25, 0x0188A5FD }, {25, 0x0188A57E }, {25, 0x0188A57F }, {25, 0x0188A5EC }, {25, 0x0188A5ED },
+    {25, 0x0188A5FE }, {25, 0x0188A5FF }, {25, 0x0188A57D }, {25, 0x0188A59C }, {25, 0x0188A59D },
+    {25, 0x0188A5E8 }, {25, 0x0188A5E9 }, {25, 0x0188A5EA }, {25, 0x0188A5EB }, {25, 0x0188A5EF },
+    {25, 0x0188A57A }, {25, 0x0188A57B }, {25, 0x0188A578 }, {25, 0x0188A579 }, {25, 0x0188A5BA },
+    {25, 0x0188A5BB }, {25, 0x0188A5B8 }, {25, 0x0188A5B9 }, {25, 0x0188A588 }, {25, 0x0188A589 },
+    {25, 0x018BA4C8 }, {25, 0x018BA4C9 }, {25, 0x0188A5FA }, {25, 0x0188A5FB }, {25, 0x0188A5BC },
+    {25, 0x0188A5BD }, {25, 0x0188A598 }, {25, 0x0188A599 }, {25, 0x0188A5F4 }, {25, 0x0188A5F5 },
+    {25, 0x0188A59B }, {25, 0x0188A5DE }, {25, 0x0188A5DF }, {25, 0x0188A596 }, {25, 0x0188A597 },
+    {25, 0x0188A5F8 }, {25, 0x0188A5F9 }, {25, 0x0188A5F1 }, {25, 0x0188A58E }, {25, 0x0188A58F },
+    {25, 0x0188A5DC }, {25, 0x0188A5DD }, {25, 0x0188A5F2 }, {25, 0x0188A5F3 }, {25, 0x0188A58C },
+    {25, 0x0188A58D }, {25, 0x0188A5A4 }, {25, 0x0188A5F0 }, {25, 0x0188A5A5 }, {25, 0x0188A5A6 },
+    {25, 0x0188A5A7 }, {25, 0x0188A59A }, {25, 0x0188A5A2 }, {25, 0x0188A5A3 }, {25, 0x0188A58A },
+    {25, 0x0188A5B0 }, {25, 0x0188A5A0 }, {25, 0x0188A5A1 }, {25, 0x0188A5DA }, {25, 0x0188A5DB },
+    {25, 0x0188A59E }, {25, 0x0188A59F }, {25, 0x0188A5D8 }, {25, 0x0188A5EE }, {25, 0x0188A5D9 },
+    {25, 0x0188A5F6 }, {25, 0x0188A5F7 }, {25, 0x0188A57C }, {25, 0x0188A5C8 }, {25, 0x0188A5C9 },
+    {25, 0x0188A594 }, {25, 0x0188A5FC }, {25, 0x0188A5CA }, {25, 0x0188A5CB }, {25, 0x0188A5B2 },
+    {25, 0x0188A5AA }, {25, 0x0188A5B3 }, {25, 0x0188A572 }, {25, 0x0188A573 }, {25, 0x0188A5C0 },
+    {25, 0x0188A5BE }, {25, 0x0188A5BF }, {25, 0x0188A592 }, {25, 0x0188A580 }, {25, 0x0188A593 },
+    {25, 0x0188A590 }, {25, 0x0188A591 }, {25, 0x0188A586 }, {25, 0x0188A5A9 }, {25, 0x0188A5D2 },
+    {25, 0x0188A5D3 }, {25, 0x0188A5D4 }, {25, 0x0188A5D5 }, {25, 0x0188A5AC }, {25, 0x0188A5AD },
+    {25, 0x0188A5D0 },
+};
+
+/* Derived by extracting runcodes from existing tables from decoder */
+static const uint16_t runbook[8][3] = {
+    {1,  0x0000,   1}, {7,  0x0069,  12}, {8,  0x00D1,  20}, {9,  0x018A,  32},
+    {10, 0x0343,  60}, {11, 0x0685, 100}, {13, 0x18BF, 180}, {13, 0x1BA5, 320},
+};
+
+/*
+ * Derived by inspecting various quality encodes
+ * and adding some more from scratch.
+ */
+static const uint16_t quantization_per_subband[10][9] = {
+    { 12, 12,  6, 12, 12,  6,  12,  12,  18, },
+    { 14, 14,  7, 14, 14,  7,  18,  18,  24, },
+    { 16, 16,  8, 16, 16,  8,  24,  24,  36, },
+    { 16, 16,  8, 16, 16,  8,  48,  48,  96, },
+    { 24, 24, 16, 24, 24, 16,  64,  64, 128, },
+    { 24, 24, 16, 24, 24, 16, 128, 128, 256, },
+    { 64, 64, 48, 64, 64, 48, 256, 256, 512, },
+    { 64, 64, 48, 64, 64, 48, 512, 512, 768, },
+    { 64, 64, 48, 64, 64, 48,1024,1024,1536, },
+    {160,160,168,172,172,180,2048,2048,3072, },
+};
+
+typedef struct Codebook {
+    unsigned bits;
+    unsigned size;
+} Codebook;
+
+typedef struct Runbook {
+    unsigned size;
+    unsigned bits;
+    unsigned run;
+} Runbook;
+
+typedef struct PlaneEnc {
+    unsigned size;
+
+    int16_t *dwt_buf;
+    int16_t *dwt_tmp;
+
+    unsigned quantization[SUBBAND_COUNT];
+    int16_t *subband[SUBBAND_COUNT];
+    int16_t *l_h[8];
+
+    SubBand band[DWT_LEVELS][4];
+} PlaneEnc;
+
+typedef struct CFHDEncContext {
+    PutBitContext       pb;
+    PutByteContext      pby;
+
+    unsigned quantization_div;
+    int compression;
+    int planes;
+    int chroma_h_shift;
+    int chroma_v_shift;
+    PlaneEnc plane[4];
+
+    Runbook  rb[321];
+    Codebook cb[513];
+} CFHDEncContext;
+
+static av_cold int cfhd_encode_init(AVCodecContext *avctx)
+{
+    CFHDEncContext *s = avctx->priv_data;
+    const int sign_mask = 256;
+    const int twos_complement = -sign_mask;
+    const int mag_mask = sign_mask - 1;
+    int ret;
+
+    s->quantization_div = avctx->pix_fmt == AV_PIX_FMT_YUV422P10 ? 2 : 1;
+
+    ret = av_pix_fmt_get_chroma_sub_sample(avctx->pix_fmt,
+                                           &s->chroma_h_shift,
+                                           &s->chroma_v_shift);
+    if (ret < 0)
+        return ret;
+
+    if (avctx->width & 15) {
+        av_log(avctx, AV_LOG_ERROR, "Width must be multiple of 16.\n");
+        return AVERROR_INVALIDDATA;
+    }
+
+    s->planes = av_pix_fmt_count_planes(avctx->pix_fmt);
+
+    if (avctx->compression_level == FF_COMPRESSION_DEFAULT)
+        s->compression = 2;
+    s->compression = av_clip(avctx->compression_level, 0, 9);
+
+    for (int i = 0; i < s->planes; i++) {
+        int w8, h8, w4, h4, w2, h2;
+        int width  = i ? avctx->width >> s->chroma_h_shift : avctx->width;
+        int height = i ? FFALIGN(avctx->height >> s->chroma_v_shift, 8) :
+                         FFALIGN(avctx->height >> s->chroma_v_shift, 8);
+        ptrdiff_t stride = FFALIGN(width / 8, 8) * 8;
+
+        w8 = FFALIGN(width / 8, 8);
+        h8 = height / 8;
+        w4 = w8 * 2;
+        h4 = h8 * 2;
+        w2 = w4 * 2;
+        h2 = h4 * 2;
+
+        s->plane[i].dwt_buf =
+            av_mallocz_array(height * stride, sizeof(*s->plane[i].dwt_buf));
+        s->plane[i].dwt_tmp =
+            av_malloc_array(height * stride, sizeof(*s->plane[i].dwt_tmp));
+        if (!s->plane[i].dwt_buf || !s->plane[i].dwt_tmp)
+            return AVERROR(ENOMEM);
+
+        s->plane[i].subband[0] = s->plane[i].dwt_buf;
+        s->plane[i].subband[1] = s->plane[i].dwt_buf + 2 * w8 * h8;
+        s->plane[i].subband[2] = s->plane[i].dwt_buf + 1 * w8 * h8;
+        s->plane[i].subband[3] = s->plane[i].dwt_buf + 3 * w8 * h8;
+        s->plane[i].subband[4] = s->plane[i].dwt_buf + 2 * w4 * h4;
+        s->plane[i].subband[5] = s->plane[i].dwt_buf + 1 * w4 * h4;
+        s->plane[i].subband[6] = s->plane[i].dwt_buf + 3 * w4 * h4;
+        s->plane[i].subband[7] = s->plane[i].dwt_buf + 2 * w2 * h2;
+        s->plane[i].subband[8] = s->plane[i].dwt_buf + 1 * w2 * h2;
+        s->plane[i].subband[9] = s->plane[i].dwt_buf + 3 * w2 * h2;
+
+        for (int j = 0; j < DWT_LEVELS; j++) {
+            for (int k = 0; k < FF_ARRAY_ELEMS(s->plane[i].band[j]); k++) {
+                s->plane[i].band[j][k].width  = (width / 8) << j;
+                s->plane[i].band[j][k].height = (height / 8) << j;
+                s->plane[i].band[j][k].a_width  = w8 << j;
+                s->plane[i].band[j][k].a_height = h8 << j;
+            }
+        }
+
+        /* ll2 and ll1 commented out because they are done in-place */
+        s->plane[i].l_h[0] = s->plane[i].dwt_tmp;
+        s->plane[i].l_h[1] = s->plane[i].dwt_tmp + 2 * w8 * h8;
+        // s->plane[i].l_h[2] = ll2;
+        s->plane[i].l_h[3] = s->plane[i].dwt_tmp;
+        s->plane[i].l_h[4] = s->plane[i].dwt_tmp + 2 * w4 * h4;
+        // s->plane[i].l_h[5] = ll1;
+        s->plane[i].l_h[6] = s->plane[i].dwt_tmp;
+        s->plane[i].l_h[7] = s->plane[i].dwt_tmp + 2 * w2 * h2;
+    }
+
+    for (int i = 0; i < 512; i++) {
+        int value = (i & sign_mask) ? twos_complement + (i & mag_mask): i;
+        int mag = FFMIN(FFABS(value), 255);
+
+        if (mag) {
+            s->cb[i].bits = (codebook[mag][1] << 1) | (value > 0 ? 0 : 1);
+            s->cb[i].size = codebook[mag][0] + 1;
+        } else {
+            s->cb[i].bits = codebook[mag][1];
+            s->cb[i].size = codebook[mag][0];
+        }
+    }
+
+    s->cb[512].bits = 0x3114ba3;
+    s->cb[512].size = 26;
+
+    s->rb[0].run = 0;
+
+    for (int i = 1, j = 0; i < 320 && j < 7; j++) {
+        int run = runbook[j][2];
+        int end = runbook[j+1][2];
+
+        while (i < end) {
+            s->rb[i].run = run;
+            s->rb[i].bits = runbook[j][1];
+            s->rb[i++].size = runbook[j][0];
+        }
+    }
+
+    s->rb[320].bits = runbook[7][1];
+    s->rb[320].size = runbook[7][0];
+    s->rb[320].run = 320;
+
+    return 0;
+}
+
+static inline void filter(int16_t *input, ptrdiff_t in_stride,
+                          int16_t *low, ptrdiff_t low_stride,
+                          int16_t *high, ptrdiff_t high_stride,
+                          int len)
+{
+    low[(0>>1) * low_stride]   = av_clip_int16(input[0*in_stride] + input[1*in_stride]);
+    high[(0>>1) * high_stride] = av_clip_int16((5 * input[0*in_stride] - 11 * input[1*in_stride] +
+                                                4 * input[2*in_stride] +  4 * input[3*in_stride] -
+                                                1 * input[4*in_stride] -  1 * input[5*in_stride] + 4) >> 3);
+
+    for (int i = 2; i < len - 2; i += 2) {
+        low[(i>>1) * low_stride]   = av_clip_int16(input[i*in_stride] + input[(i+1)*in_stride]);
+        high[(i>>1) * high_stride] = av_clip_int16(((-input[(i-2)*in_stride] - input[(i-1)*in_stride] +
+                                                      input[(i+2)*in_stride] + input[(i+3)*in_stride] + 4) >> 3) +
+                                                      input[(i+0)*in_stride] - input[(i+1)*in_stride]);
+    }
+
+    low[((len-2)>>1) * low_stride]   = av_clip_int16(input[((len-2)+0)*in_stride] + input[((len-2)+1)*in_stride]);
+    high[((len-2)>>1) * high_stride] = av_clip_int16((11* input[((len-2)+0)*in_stride] - 5 * input[((len-2)+1)*in_stride] -
+                                                      4 * input[((len-2)-1)*in_stride] - 4 * input[((len-2)-2)*in_stride] +
+                                                      1 * input[((len-2)-3)*in_stride] + 1 * input[((len-2)-4)*in_stride] + 4) >> 3);
+}
+
+static void horiz_filter(int16_t *input, int16_t *low, int16_t *high,
+                         int width)
+{
+    filter(input, 1, low, 1, high, 1, width);
+}
+
+static void vert_filter(int16_t *input, ptrdiff_t in_stride,
+                        int16_t *low, ptrdiff_t low_stride,
+                        int16_t *high, ptrdiff_t high_stride, int len)
+{
+    filter(input, in_stride, low, low_stride, high, high_stride, len);
+}
+
+static void quantize_band(int16_t *input, int width, int a_width,
+                          int height, unsigned quantization)
+{
+    const int factor = (1 << 16) / quantization;
+
+    for (int i = 0; i < height; i++) {
+        for (int j = 0; j < width; j++)
+            input[j] = av_clip_intp2((input[j] * factor) / 65536, 8);
+        input += a_width;
+    }
+}
+
+static int put_runcode(PutBitContext *pb, int count, const Runbook *const rb)
+{
+    while (count > 0) {
+        const int index = FFMIN(320, count);
+
+        put_bits(pb, rb[index].size, rb[index].bits);
+        count -= rb[index].run;
+    }
+
+    return 0;
+}
+
+static int cfhd_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
+                             const AVFrame *frame, int *got_packet)
+{
+    CFHDEncContext *s = avctx->priv_data;
+    PutByteContext *pby = &s->pby;
+    PutBitContext *pb = &s->pb;
+    const Codebook *const cb = s->cb;
+    const Runbook *const rb = s->rb;
+    unsigned pos;
+    int ret = 0;
+
+    for (int plane = 0; plane < s->planes && !ret; plane++) {
+        int width = s->plane[plane].band[2][0].width;
+        int a_width = s->plane[plane].band[2][0].a_width;
+        int height = s->plane[plane].band[2][0].height;
+        int act_plane = plane == 1 ? 2 : plane == 2 ? 1 : plane;
+        int16_t *input = (int16_t *)frame->data[act_plane];
+        int16_t *low = s->plane[plane].l_h[6];
+        int16_t *high = s->plane[plane].l_h[7];
+        const ptrdiff_t in_stride = frame->linesize[act_plane] / 2;
+        int low_stride, high_stride;
+
+        for (int i = 0; i < height * 2; i++) {
+            horiz_filter(input, low, high, width * 2);
+            input += in_stride;
+            low += a_width;
+            high += a_width;
+        }
+
+        input = s->plane[plane].l_h[7];
+        low = s->plane[plane].subband[7];
+        low_stride = s->plane[plane].band[2][0].a_width;
+        high = s->plane[plane].subband[9];
+        high_stride = s->plane[plane].band[2][0].a_width;
+
+        for (int i = 0; i < width; i++) {
+            vert_filter(input, a_width, low, low_stride, high, high_stride, height * 2);
+            input++;
+            low++;
+            high++;
+        }
+
+        input = s->plane[plane].l_h[6];
+        low = s->plane[plane].l_h[7];
+        high = s->plane[plane].subband[8];
+
+        for (int i = 0; i < width; i++) {
+            vert_filter(input, a_width, low, low_stride, high, high_stride, height * 2);
+            input++;
+            low++;
+            high++;
+        }
+
+        a_width = s->plane[plane].band[1][0].a_width;
+        width = s->plane[plane].band[1][0].width;
+        height = s->plane[plane].band[1][0].height;
+        input = s->plane[plane].l_h[7];
+        low = s->plane[plane].l_h[3];
+        low_stride = s->plane[plane].band[1][0].a_width;
+        high = s->plane[plane].l_h[4];
+        high_stride = s->plane[plane].band[1][0].a_width;
+
+        for (int i = 0; i < height * 2; i++) {
+            for (int j = 0; j < width * 2; j++)
+                input[j] /= 4;
+            input += a_width * 2;
+        }
+
+        input = s->plane[plane].l_h[7];
+        for (int i = 0; i < height * 2; i++) {
+            horiz_filter(input, low, high, width * 2);
+            input += a_width * 2;
+            low += low_stride;
+            high += high_stride;
+        }
+
+        input = s->plane[plane].l_h[4];
+        low = s->plane[plane].subband[4];
+        high = s->plane[plane].subband[6];
+
+        for (int i = 0; i < width; i++) {
+            vert_filter(input, a_width, low, low_stride, high, high_stride, height * 2);
+            input++;
+            low++;
+            high++;
+        }
+
+        input = s->plane[plane].l_h[3];
+        low = s->plane[plane].l_h[4];
+        high = s->plane[plane].subband[5];
+
+        for (int i = 0; i < width; i++) {
+            vert_filter(input, a_width, low, low_stride, high, high_stride, height * 2);
+            input++;
+            low++;
+            high++;
+        }
+
+        a_width = s->plane[plane].band[0][0].a_width;
+        width = s->plane[plane].band[0][0].width;
+        height = s->plane[plane].band[0][0].height;
+        input = s->plane[plane].l_h[4];
+        low = s->plane[plane].l_h[0];
+        low_stride = s->plane[plane].band[0][0].a_width;
+        high = s->plane[plane].l_h[1];
+        high_stride = s->plane[plane].band[0][0].a_width;
+
+        if (avctx->pix_fmt != AV_PIX_FMT_YUV422P10) {
+            for (int i = 0; i < height * 2; i++) {
+                for (int j = 0; j < width * 2; j++)
+                    input[j] /= 4;
+                input += a_width * 2;
+            }
+        }
+
+        input = s->plane[plane].l_h[4];
+        for (int i = 0; i < height * 2; i++) {
+            horiz_filter(input, low, high, width * 2);
+            input += a_width * 2;
+            low += low_stride;
+            high += high_stride;
+        }
+
+        low = s->plane[plane].subband[1];
+        high = s->plane[plane].subband[3];
+        input = s->plane[plane].l_h[1];
+
+        for (int i = 0; i < width; i++) {
+            vert_filter(input, a_width, low, low_stride, high, high_stride, height * 2);
+            input++;
+            low++;
+            high++;
+        }
+
+        low = s->plane[plane].subband[0];
+        high = s->plane[plane].subband[2];
+        input = s->plane[plane].l_h[0];
+
+        for (int i = 0; i < width; i++) {
+            vert_filter(input, a_width, low, low_stride, high, high_stride, height * 2);
+            input++;
+            low++;
+            high++;
+        }
+    }
+
+    ret = ff_alloc_packet2(avctx, pkt, 60LL + s->planes * (2LL * avctx->width * avctx->height + 1000LL), 0);
+    if (ret < 0)
+        return ret;
+
+    bytestream2_init_writer(pby, pkt->data, pkt->size);
+
+    bytestream2_put_be16(pby, SampleType);
+    bytestream2_put_be16(pby, 9);
+
+    bytestream2_put_be16(pby, SampleIndexTable);
+    bytestream2_put_be16(pby, s->planes);
+
+    for (int i = 0; i < s->planes; i++)
+        bytestream2_put_be32(pby, 0);
+
+    bytestream2_put_be16(pby, TransformType);
+    bytestream2_put_be16(pby, 0);
+
+    bytestream2_put_be16(pby, NumFrames);
+    bytestream2_put_be16(pby, 1);
+
+    bytestream2_put_be16(pby, ChannelCount);
+    bytestream2_put_be16(pby, s->planes);
+
+    bytestream2_put_be16(pby, EncodedFormat);
+    bytestream2_put_be16(pby, avctx->pix_fmt == AV_PIX_FMT_YUV422P10 ? 1 : 3);
+
+    bytestream2_put_be16(pby, WaveletCount);
+    bytestream2_put_be16(pby, 3);
+
+    bytestream2_put_be16(pby, SubbandCount);
+    bytestream2_put_be16(pby, SUBBAND_COUNT);
+
+    bytestream2_put_be16(pby, NumSpatial);
+    bytestream2_put_be16(pby, 2);
+
+    bytestream2_put_be16(pby, FirstWavelet);
+    bytestream2_put_be16(pby, 3);
+
+    bytestream2_put_be16(pby, ImageWidth);
+    bytestream2_put_be16(pby, avctx->width);
+
+    bytestream2_put_be16(pby, ImageHeight);
+    bytestream2_put_be16(pby, avctx->height);
+
+    bytestream2_put_be16(pby, Precision);
+    bytestream2_put_be16(pby, avctx->pix_fmt == AV_PIX_FMT_YUV422P10 ? 10 : 12);
+
+    bytestream2_put_be16(pby, PrescaleTable);
+    bytestream2_put_be16(pby, 0x2800);
+
+    bytestream2_put_be16(pby, SampleFlags);
+    bytestream2_put_be16(pby, 1);
+
+    for (int p = 0; p < s->planes; p++) {
+        int width = s->plane[p].band[0][0].width;
+        int a_width = s->plane[p].band[0][0].a_width;
+        int height = s->plane[p].band[0][0].height;
+        int16_t *data = s->plane[p].subband[0];
+
+        if (p) {
+            bytestream2_put_be16(pby, SampleType);
+            bytestream2_put_be16(pby, 3);
+
+            bytestream2_put_be16(pby, ChannelNumber);
+            bytestream2_put_be16(pby, p);
+        }
+
+        bytestream2_put_be16(pby, BitstreamMarker);
+        bytestream2_put_be16(pby, 0x1a4a);
+
+        pos = bytestream2_tell_p(pby);
+
+        bytestream2_put_be16(pby, LowpassSubband);
+        bytestream2_put_be16(pby, 0);
+
+        bytestream2_put_be16(pby, NumLevels);
+        bytestream2_put_be16(pby, 3);
+
+        bytestream2_put_be16(pby, LowpassWidth);
+        bytestream2_put_be16(pby, width);
+
+        bytestream2_put_be16(pby, LowpassHeight);
+        bytestream2_put_be16(pby, height);
+
+        bytestream2_put_be16(pby, PixelOffset);
+        bytestream2_put_be16(pby, 0);
+
+        bytestream2_put_be16(pby, LowpassQuantization);
+        bytestream2_put_be16(pby, 1);
+
+        bytestream2_put_be16(pby, LowpassPrecision);
+        bytestream2_put_be16(pby, 16);
+
+        bytestream2_put_be16(pby, BitstreamMarker);
+        bytestream2_put_be16(pby, 0x0f0f);
+
+        for (int i = 0; i < height; i++) {
+            for (int j = 0; j < width; j++)
+                bytestream2_put_be16(pby, data[j]);
+            data += a_width;
+        }
+
+        bytestream2_put_be16(pby, BitstreamMarker);
+        bytestream2_put_be16(pby, 0x1b4b);
+
+        for (int l = 0; l < 3; l++) {
+            for (int i = 0; i < 3; i++) {
+                s->plane[p].quantization[1 + l * 3 + i] = quantization_per_subband[s->compression][l * 3 + i] / s->quantization_div;
+            }
+        }
+
+        for (int l = 0; l < 3; l++) {
+            int a_width = s->plane[p].band[l][0].a_width;
+            int width = s->plane[p].band[l][0].width;
+            int stride = FFALIGN(width, 8);
+            int height = s->plane[p].band[l][0].height;
+
+            bytestream2_put_be16(pby, BitstreamMarker);
+            bytestream2_put_be16(pby, 0x0d0d);
+
+            bytestream2_put_be16(pby, WaveletType);
+            bytestream2_put_be16(pby, 3 + 2 * (l == 2));
+
+            bytestream2_put_be16(pby, WaveletNumber);
+            bytestream2_put_be16(pby, 3 - l);
+
+            bytestream2_put_be16(pby, WaveletLevel);
+            bytestream2_put_be16(pby, 3 - l);
+
+            bytestream2_put_be16(pby, NumBands);
+            bytestream2_put_be16(pby, 4);
+
+            bytestream2_put_be16(pby, HighpassWidth);
+            bytestream2_put_be16(pby, width);
+
+            bytestream2_put_be16(pby, HighpassHeight);
+            bytestream2_put_be16(pby, height);
+
+            bytestream2_put_be16(pby, LowpassBorder);
+            bytestream2_put_be16(pby, 0);
+
+            bytestream2_put_be16(pby, HighpassBorder);
+            bytestream2_put_be16(pby, 0);
+
+            bytestream2_put_be16(pby, LowpassScale);
+            bytestream2_put_be16(pby, 1);
+
+            bytestream2_put_be16(pby, LowpassDivisor);
+            bytestream2_put_be16(pby, 1);
+
+            for (int i = 0; i < 3; i++) {
+                int16_t *data = s->plane[p].subband[1 + l * 3 + i];
+                int count = 0, padd = 0;
+
+                bytestream2_put_be16(pby, BitstreamMarker);
+                bytestream2_put_be16(pby, 0x0e0e);
+
+                bytestream2_put_be16(pby, SubbandNumber);
+                bytestream2_put_be16(pby, i + 1);
+
+                bytestream2_put_be16(pby, BandCodingFlags);
+                bytestream2_put_be16(pby, 2);
+
+                bytestream2_put_be16(pby, BandWidth);
+                bytestream2_put_be16(pby, width);
+
+                bytestream2_put_be16(pby, BandHeight);
+                bytestream2_put_be16(pby, height);
+
+                bytestream2_put_be16(pby, SubbandBand);
+                bytestream2_put_be16(pby, 1 + l * 3 + i);
+
+                bytestream2_put_be16(pby, BandEncoding);
+                bytestream2_put_be16(pby, 3);
+
+                bytestream2_put_be16(pby, Quantization);
+                bytestream2_put_be16(pby, s->plane[p].quantization[1 + l * 3 + i]);
+
+                bytestream2_put_be16(pby, BandScale);
+                bytestream2_put_be16(pby, 1);
+
+                bytestream2_put_be16(pby, BandHeader);
+                bytestream2_put_be16(pby, 0);
+
+                quantize_band(data, width, a_width, height,
+                              s->plane[p].quantization[1 + l * 3 + i]);
+
+                init_put_bits(pb, pkt->data + bytestream2_tell_p(pby), bytestream2_get_bytes_left_p(pby));
+
+                for (int m = 0; m < height; m++) {
+                    for (int j = 0; j < stride; j++) {
+                        int16_t index = data[j];
+
+                        if (index < 0)
+                            index += 512;
+                        if (index == 0) {
+                            count++;
+                            continue;
+                        } else if (count > 0) {
+                            count = put_runcode(pb, count, rb);
+                        }
+
+                        put_bits(pb, cb[index].size, cb[index].bits);
+                    }
+
+                    data += a_width;
+                }
+
+                if (count > 0) {
+                    count = put_runcode(pb, count, rb);
+                }
+
+                put_bits(pb, cb[512].size, cb[512].bits);
+
+                flush_put_bits(pb);
+                bytestream2_skip_p(pby, put_bits_count(pb) >> 3);
+                padd = (4 - (bytestream2_tell_p(pby) & 3)) & 3;
+                while (padd--)
+                    bytestream2_put_byte(pby, 0);
+
+                bytestream2_put_be16(pby, BandTrailer);
+                bytestream2_put_be16(pby, 0);
+            }
+
+            bytestream2_put_be16(pby, BitstreamMarker);
+            bytestream2_put_be16(pby, 0x0c0c);
+        }
+
+        s->plane[p].size = bytestream2_tell_p(pby) - pos;
+    }
+
+    bytestream2_put_be16(pby, GroupTrailer);
+    bytestream2_put_be16(pby, 0);
+
+    av_shrink_packet(pkt, bytestream2_tell_p(pby));
+
+    pkt->flags |= AV_PKT_FLAG_KEY;
+
+    bytestream2_seek_p(pby, 8, SEEK_SET);
+    for (int i = 0; i < s->planes; i++)
+        bytestream2_put_be32(pby, s->plane[i].size);
+
+    *got_packet = 1;
+
+    return 0;
+}
+
+static av_cold int cfhd_encode_close(AVCodecContext *avctx)
+{
+    CFHDEncContext *s = avctx->priv_data;
+
+    for (int i = 0; i < s->planes; i++) {
+        av_freep(&s->plane[i].dwt_buf);
+        av_freep(&s->plane[i].dwt_tmp);
+
+        for (int j = 0; j < SUBBAND_COUNT; j++)
+            s->plane[i].subband[j] = NULL;
+
+        for (int j = 0; j < 8; j++)
+            s->plane[i].l_h[j] = NULL;
+    }
+
+    return 0;
+}
+
+AVCodec ff_cfhd_encoder = {
+    .name             = "cfhd",
+    .long_name        = NULL_IF_CONFIG_SMALL("Cineform HD"),
+    .type             = AVMEDIA_TYPE_VIDEO,
+    .id               = AV_CODEC_ID_CFHD,
+    .priv_data_size   = sizeof(CFHDEncContext),
+    .init             = cfhd_encode_init,
+    .close            = cfhd_encode_close,
+    .encode2          = cfhd_encode_frame,
+    .capabilities     = AV_CODEC_CAP_FRAME_THREADS,
+    .pix_fmts         = (const enum AVPixelFormat[]) {
+                          AV_PIX_FMT_YUV422P10,
+                          AV_PIX_FMT_GBRP12,
+                          AV_PIX_FMT_NONE
+                        },
+};