git.sesse.net Git - ffmpeg/blob - libavcodec/cfhdenc.c

   1 /*
   2  * Copyright (c) 2020 Paul B Mahol
   3  *
   4  * This file is part of FFmpeg.
   5  *
   6  * FFmpeg is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * FFmpeg is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with FFmpeg; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  19  */
  20
  21 /**
  22  * @file
  23  * Cineform HD video encoder
  24  */
  25
  26 #include <stdlib.h>
  27 #include <string.h>
  28
  29 #include "libavutil/avassert.h"
  30 #include "libavutil/imgutils.h"
  31 #include "libavutil/opt.h"
  32
  33 #include "avcodec.h"
  34 #include "bytestream.h"
  35 #include "cfhd.h"
  36 #include "put_bits.h"
  37 #include "internal.h"
  38 #include "thread.h"
  39
  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 },
  93     {25, 0x0188A5D0 },
  94 };
  95
  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},
 100 };
 101
 102 /*
 103  * Derived by inspecting various quality encodes
 104  * and adding some more from scratch.
 105  */
 106 static const uint16_t quantization_per_subband[2][3][11][9] = {
 107     {{
 108         { 16, 16,  8,  4,  4,  2,   6,   6,   9, }, // film3+
 109         { 16, 16,  8,  4,  4,  2,   6,   6,   9, }, // film3
 110         { 16, 16,  8,  4,  4,  2,   8,   8,  12, }, // film2+
 111         { 16, 16,  8,  4,  4,  2,   8,   8,  12, }, // film2
 112         { 24, 24, 12,  6,  6,  3,  24,  24,  36, }, // film1+
 113         { 24, 24, 12,  6,  6,  3,  24,  24,  36, }, // film1
 114         { 32, 32, 24,  8,  8,  6,  32,  32,  48, }, // high+
 115         { 32, 32, 24,  8,  8,  6,  32,  32,  48, }, // high
 116         { 48, 48, 32, 12, 12,  8,  64,  64,  96, }, // medium+
 117         { 48, 48, 32, 12, 12,  8,  64,  64,  96, }, // medium
 118         { 64, 64, 48, 16, 16, 12, 128, 128, 192, }, // low
 119     },
 120     {
 121         { 16, 16,  8,  4,  4,  2,   6,   6,   9, },
 122         { 16, 16,  8,  4,  4,  2,   6,   6,  12, },
 123         { 16, 16,  8,  4,  4,  2,   8,   8,  12, },
 124         { 16, 16,  8,  4,  4,  2,   8,   8,  16, },
 125         { 24, 24, 12,  6,  6,  3,  24,  24,  36, },
 126         { 24, 24, 12,  6,  6,  3,  24,  24,  48, },
 127         { 32, 32, 24,  8,  8,  6,  32,  32,  48, },
 128         { 48, 48, 32, 12, 12,  8,  32,  32,  64, },
 129         { 48, 48, 32, 12, 12,  8,  64,  64,  96, },
 130         { 48, 48, 32, 12, 12,  8,  64,  64, 128, },
 131         { 64, 64, 48, 16, 16, 12, 128, 128, 192, },
 132     },
 133     {
 134         { 16, 16,  8,  4,  4,  2,   6,   6,   9, },
 135         { 16, 16,  8,  4,  4,  2,   6,   6,  12, },
 136         { 16, 16,  8,  4,  4,  2,   8,   8,  12, },
 137         { 16, 16,  8,  4,  4,  2,   8,   8,  16, },
 138         { 24, 24, 12,  6,  6,  3,  24,  24,  36, },
 139         { 24, 24, 12,  6,  6,  3,  24,  24,  48, },
 140         { 32, 32, 24,  8,  8,  6,  32,  32,  48, },
 141         { 48, 48, 32, 12, 12,  8,  32,  32,  64, },
 142         { 48, 48, 32, 12, 12,  8,  64,  64,  96, },
 143         { 48, 48, 32, 12, 12,  8,  64,  64, 128, },
 144         { 64, 64, 48, 16, 16, 12, 128, 128, 192, },
 145     }},
 146     {{
 147         { 16, 16,  8, 16, 16,  8,  24,  24,  36, },
 148         { 16, 16,  8, 16, 16,  8,  32,  32,  48, },
 149         { 16, 16,  8, 16, 16,  8,  48,  48,  72, },
 150         { 16, 16,  8, 16, 16,  8,  64,  64,  96, },
 151         { 24, 24, 12, 24, 24, 12,  96,  96, 144, },
 152         { 24, 24, 12, 24, 24, 12, 192, 192, 288, },
 153         { 32, 32, 24, 32, 32, 24, 128, 128, 192, },
 154         { 32, 32, 24, 32, 32, 24, 256, 256, 384, },
 155         { 48, 48, 32, 48, 48, 32, 256, 256, 384, },
 156         { 48, 48, 32, 48, 48, 32, 512, 512, 768, },
 157         { 64, 64, 48, 64, 64, 48, 512, 512, 768, },
 158     },
 159     {
 160         { 16, 16,  8, 16, 16,  8,  24,  24,  36, },
 161         { 16, 16,  8, 16, 16,  8,  32,  32,  48, },
 162         { 16, 16,  8, 16, 16,  8,  48,  48,  72, },
 163         { 16, 16,  8, 16, 16,  8,  64,  64,  96, },
 164         { 24, 24, 12, 24, 24, 12,  96,  96, 144, },
 165         { 24, 24, 12, 24, 24, 12, 192, 192, 288, },
 166         { 32, 32, 24, 32, 32, 24, 128, 128, 192, },
 167         { 32, 32, 24, 32, 32, 24, 256, 256, 384, },
 168         { 48, 48, 32, 48, 48, 32, 256, 256, 384, },
 169         { 48, 48, 32, 48, 48, 32, 512, 512, 768, },
 170         { 64, 64, 48, 64, 64, 48, 512, 512, 768, },
 171     },
 172     {
 173         { 16, 16,  8, 16, 16,  8,  24,  24,  36, },
 174         { 16, 16,  8, 16, 16,  8,  32,  32,  48, },
 175         { 16, 16,  8, 16, 16,  8,  48,  48,  72, },
 176         { 16, 16,  8, 16, 16,  8,  64,  64,  96, },
 177         { 24, 24, 12, 24, 24, 12,  96,  96, 144, },
 178         { 24, 24, 12, 24, 24, 12, 192, 192, 288, },
 179         { 32, 32, 24, 32, 32, 24, 128, 128, 192, },
 180         { 32, 32, 24, 32, 32, 24, 256, 256, 384, },
 181         { 48, 48, 32, 48, 48, 32, 256, 256, 384, },
 182         { 48, 48, 32, 48, 48, 32, 512, 512, 768, },
 183         { 64, 64, 48, 64, 64, 48, 512, 512, 768, },
 184     }},
 185 };
 186
 187 typedef struct Codebook {
 188     unsigned bits;
 189     unsigned size;
 190 } Codebook;
 191
 192 typedef struct Runbook {
 193     unsigned size;
 194     unsigned bits;
 195     unsigned run;
 196 } Runbook;
 197
 198 typedef struct PlaneEnc {
 199     unsigned size;
 200
 201     int16_t *dwt_buf;
 202     int16_t *dwt_tmp;
 203
 204     unsigned quantization[SUBBAND_COUNT];
 205     int16_t *subband[SUBBAND_COUNT];
 206     int16_t *l_h[8];
 207
 208     SubBand band[DWT_LEVELS][4];
 209 } PlaneEnc;
 210
 211 typedef struct CFHDEncContext {
 212     PutBitContext       pb;
 213     PutByteContext      pby;
 214
 215     int compression;
 216     int planes;
 217     int chroma_h_shift;
 218     int chroma_v_shift;
 219     PlaneEnc plane[4];
 220
 221     Runbook  rb[321];
 222     Codebook cb[513];
 223 } CFHDEncContext;
 224
 225 static av_cold int cfhd_encode_init(AVCodecContext *avctx)
 226 {
 227     CFHDEncContext *s = avctx->priv_data;
 228     const int sign_mask = 256;
 229     const int twos_complement = -sign_mask;
 230     const int mag_mask = sign_mask - 1;
 231     int ret;
 232
 233     ret = av_pix_fmt_get_chroma_sub_sample(avctx->pix_fmt,
 234                                            &s->chroma_h_shift,
 235                                            &s->chroma_v_shift);
 236     if (ret < 0)
 237         return ret;
 238
 239     if (avctx->width & 15) {
 240         av_log(avctx, AV_LOG_ERROR, "Width must be multiple of 16.\n");
 241         return AVERROR_INVALIDDATA;
 242     }
 243
 244     s->planes = av_pix_fmt_count_planes(avctx->pix_fmt);
 245     s->compression = avctx->compression_level;
 246
 247     if (s->compression == FF_COMPRESSION_DEFAULT)
 248         s->compression = 2;
 249     s->compression = av_clip(s->compression, 0, 10);
 250
 251     for (int i = 0; i < s->planes; i++) {
 252         int w8, h8, w4, h4, w2, h2;
 253         int width  = i ? avctx->width >> s->chroma_h_shift : avctx->width;
 254         int height = i ? FFALIGN(avctx->height >> s->chroma_v_shift, 8) :
 255                          FFALIGN(avctx->height >> s->chroma_v_shift, 8);
 256         ptrdiff_t stride = FFALIGN(width / 8, 8) * 8;
 257
 258         w8 = FFALIGN(width / 8, 8);
 259         h8 = height / 8;
 260         w4 = w8 * 2;
 261         h4 = h8 * 2;
 262         w2 = w4 * 2;
 263         h2 = h4 * 2;
 264
 265         s->plane[i].dwt_buf =
 266             av_mallocz_array(height * stride, sizeof(*s->plane[i].dwt_buf));
 267         s->plane[i].dwt_tmp =
 268             av_malloc_array(height * stride, sizeof(*s->plane[i].dwt_tmp));
 269         if (!s->plane[i].dwt_buf || !s->plane[i].dwt_tmp)
 270             return AVERROR(ENOMEM);
 271
 272         s->plane[i].subband[0] = s->plane[i].dwt_buf;
 273         s->plane[i].subband[1] = s->plane[i].dwt_buf + 2 * w8 * h8;
 274         s->plane[i].subband[2] = s->plane[i].dwt_buf + 1 * w8 * h8;
 275         s->plane[i].subband[3] = s->plane[i].dwt_buf + 3 * w8 * h8;
 276         s->plane[i].subband[4] = s->plane[i].dwt_buf + 2 * w4 * h4;
 277         s->plane[i].subband[5] = s->plane[i].dwt_buf + 1 * w4 * h4;
 278         s->plane[i].subband[6] = s->plane[i].dwt_buf + 3 * w4 * h4;
 279         s->plane[i].subband[7] = s->plane[i].dwt_buf + 2 * w2 * h2;
 280         s->plane[i].subband[8] = s->plane[i].dwt_buf + 1 * w2 * h2;
 281         s->plane[i].subband[9] = s->plane[i].dwt_buf + 3 * w2 * h2;
 282
 283         for (int j = 0; j < DWT_LEVELS; j++) {
 284             for (int k = 0; k < FF_ARRAY_ELEMS(s->plane[i].band[j]); k++) {
 285                 s->plane[i].band[j][k].width  = (width / 8) << j;
 286                 s->plane[i].band[j][k].height = (height / 8) << j;
 287                 s->plane[i].band[j][k].a_width  = w8 << j;
 288                 s->plane[i].band[j][k].a_height = h8 << j;
 289             }
 290         }
 291
 292         /* ll2 and ll1 commented out because they are done in-place */
 293         s->plane[i].l_h[0] = s->plane[i].dwt_tmp;
 294         s->plane[i].l_h[1] = s->plane[i].dwt_tmp + 2 * w8 * h8;
 295         // s->plane[i].l_h[2] = ll2;
 296         s->plane[i].l_h[3] = s->plane[i].dwt_tmp;
 297         s->plane[i].l_h[4] = s->plane[i].dwt_tmp + 2 * w4 * h4;
 298         // s->plane[i].l_h[5] = ll1;
 299         s->plane[i].l_h[6] = s->plane[i].dwt_tmp;
 300         s->plane[i].l_h[7] = s->plane[i].dwt_tmp + 2 * w2 * h2;
 301     }
 302
 303     for (int i = 0; i < 512; i++) {
 304         int value = (i & sign_mask) ? twos_complement + (i & mag_mask): i;
 305         int mag = FFMIN(FFABS(value), 255);
 306
 307         if (mag) {
 308             s->cb[i].bits = (codebook[mag][1] << 1) | (value > 0 ? 0 : 1);
 309             s->cb[i].size = codebook[mag][0] + 1;
 310         } else {
 311             s->cb[i].bits = codebook[mag][1];
 312             s->cb[i].size = codebook[mag][0];
 313         }
 314     }
 315
 316     s->cb[512].bits = 0x3114ba3;
 317     s->cb[512].size = 26;
 318
 319     s->rb[0].run = 0;
 320
 321     for (int i = 1, j = 0; i < 320 && j < 7; j++) {
 322         int run = runbook[j][2];
 323         int end = runbook[j+1][2];
 324
 325         while (i < end) {
 326             s->rb[i].run = run;
 327             s->rb[i].bits = runbook[j][1];
 328             s->rb[i++].size = runbook[j][0];
 329         }
 330     }
 331
 332     s->rb[320].bits = runbook[7][1];
 333     s->rb[320].size = runbook[7][0];
 334     s->rb[320].run = 320;
 335
 336     return 0;
 337 }
 338
 339 static inline void filter(int16_t *input, ptrdiff_t in_stride,
 340                           int16_t *low, ptrdiff_t low_stride,
 341                           int16_t *high, ptrdiff_t high_stride,
 342                           int len)
 343 {
 344     low[(0>>1) * low_stride]   = av_clip_int16(input[0*in_stride] + input[1*in_stride]);
 345     high[(0>>1) * high_stride] = av_clip_int16((5 * input[0*in_stride] - 11 * input[1*in_stride] +
 346                                                 4 * input[2*in_stride] +  4 * input[3*in_stride] -
 347                                                 1 * input[4*in_stride] -  1 * input[5*in_stride] + 4) >> 3);
 348
 349     for (int i = 2; i < len - 2; i += 2) {
 350         low[(i>>1) * low_stride]   = av_clip_int16(input[i*in_stride] + input[(i+1)*in_stride]);
 351         high[(i>>1) * high_stride] = av_clip_int16(((-input[(i-2)*in_stride] - input[(i-1)*in_stride] +
 352                                                       input[(i+2)*in_stride] + input[(i+3)*in_stride] + 4) >> 3) +
 353                                                       input[(i+0)*in_stride] - input[(i+1)*in_stride]);
 354     }
 355
 356     low[((len-2)>>1) * low_stride]   = av_clip_int16(input[((len-2)+0)*in_stride] + input[((len-2)+1)*in_stride]);
 357     high[((len-2)>>1) * high_stride] = av_clip_int16((11* input[((len-2)+0)*in_stride] - 5 * input[((len-2)+1)*in_stride] -
 358                                                       4 * input[((len-2)-1)*in_stride] - 4 * input[((len-2)-2)*in_stride] +
 359                                                       1 * input[((len-2)-3)*in_stride] + 1 * input[((len-2)-4)*in_stride] + 4) >> 3);
 360 }
 361
 362 static void horiz_filter(int16_t *input, int16_t *low, int16_t *high,
 363                          int width)
 364 {
 365     filter(input, 1, low, 1, high, 1, width);
 366 }
 367
 368 static void vert_filter(int16_t *input, ptrdiff_t in_stride,
 369                         int16_t *low, ptrdiff_t low_stride,
 370                         int16_t *high, ptrdiff_t high_stride, int len)
 371 {
 372     filter(input, in_stride, low, low_stride, high, high_stride, len);
 373 }
 374
 375 static void quantize_band(int16_t *input, int width, int a_width,
 376                           int height, unsigned quantization)
 377 {
 378     const int factor = (1 << 16) / quantization;
 379
 380     for (int i = 0; i < height; i++) {
 381         for (int j = 0; j < width; j++)
 382             input[j] = av_clip_intp2((input[j] * factor) / 65536, 8);
 383         input += a_width;
 384     }
 385 }
 386
 387 static int put_runcode(PutBitContext *pb, int count, const Runbook *const rb)
 388 {
 389     while (count > 0) {
 390         const int index = FFMIN(320, count);
 391
 392         put_bits(pb, rb[index].size, rb[index].bits);
 393         count -= rb[index].run;
 394     }
 395
 396     return 0;
 397 }
 398
 399 static int cfhd_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
 400                              const AVFrame *frame, int *got_packet)
 401 {
 402     CFHDEncContext *s = avctx->priv_data;
 403     PutByteContext *pby = &s->pby;
 404     PutBitContext *pb = &s->pb;
 405     const Codebook *const cb = s->cb;
 406     const Runbook *const rb = s->rb;
 407     unsigned pos;
 408     int ret = 0;
 409
 410     for (int plane = 0; plane < s->planes && !ret; plane++) {
 411         int width = s->plane[plane].band[2][0].width;
 412         int a_width = s->plane[plane].band[2][0].a_width;
 413         int height = s->plane[plane].band[2][0].height;
 414         int act_plane = plane == 1 ? 2 : plane == 2 ? 1 : plane;
 415         int16_t *input = (int16_t *)frame->data[act_plane];
 416         int16_t *low = s->plane[plane].l_h[6];
 417         int16_t *high = s->plane[plane].l_h[7];
 418         const ptrdiff_t in_stride = frame->linesize[act_plane] / 2;
 419         int low_stride, high_stride;
 420
 421         for (int i = 0; i < height * 2; i++) {
 422             horiz_filter(input, low, high, width * 2);
 423             input += in_stride;
 424             low += a_width;
 425             high += a_width;
 426         }
 427
 428         input = s->plane[plane].l_h[7];
 429         low = s->plane[plane].subband[7];
 430         low_stride = s->plane[plane].band[2][0].a_width;
 431         high = s->plane[plane].subband[9];
 432         high_stride = s->plane[plane].band[2][0].a_width;
 433
 434         for (int i = 0; i < width; i++) {
 435             vert_filter(input, a_width, low, low_stride, high, high_stride, height * 2);
 436             input++;
 437             low++;
 438             high++;
 439         }
 440
 441         input = s->plane[plane].l_h[6];
 442         low = s->plane[plane].l_h[7];
 443         high = s->plane[plane].subband[8];
 444
 445         for (int i = 0; i < width; i++) {
 446             vert_filter(input, a_width, low, low_stride, high, high_stride, height * 2);
 447             input++;
 448             low++;
 449             high++;
 450         }
 451
 452         a_width = s->plane[plane].band[1][0].a_width;
 453         width = s->plane[plane].band[1][0].width;
 454         height = s->plane[plane].band[1][0].height;
 455         input = s->plane[plane].l_h[7];
 456         low = s->plane[plane].l_h[3];
 457         low_stride = s->plane[plane].band[1][0].a_width;
 458         high = s->plane[plane].l_h[4];
 459         high_stride = s->plane[plane].band[1][0].a_width;
 460
 461         for (int i = 0; i < height * 2; i++) {
 462             for (int j = 0; j < width * 2; j++)
 463                 input[j] /= 4;
 464             input += a_width * 2;
 465         }
 466
 467         input = s->plane[plane].l_h[7];
 468         for (int i = 0; i < height * 2; i++) {
 469             horiz_filter(input, low, high, width * 2);
 470             input += a_width * 2;
 471             low += low_stride;
 472             high += high_stride;
 473         }
 474
 475         input = s->plane[plane].l_h[4];
 476         low = s->plane[plane].subband[4];
 477         high = s->plane[plane].subband[6];
 478
 479         for (int i = 0; i < width; i++) {
 480             vert_filter(input, a_width, low, low_stride, high, high_stride, height * 2);
 481             input++;
 482             low++;
 483             high++;
 484         }
 485
 486         input = s->plane[plane].l_h[3];
 487         low = s->plane[plane].l_h[4];
 488         high = s->plane[plane].subband[5];
 489
 490         for (int i = 0; i < width; i++) {
 491             vert_filter(input, a_width, low, low_stride, high, high_stride, height * 2);
 492             input++;
 493             low++;
 494             high++;
 495         }
 496
 497         a_width = s->plane[plane].band[0][0].a_width;
 498         width = s->plane[plane].band[0][0].width;
 499         height = s->plane[plane].band[0][0].height;
 500         input = s->plane[plane].l_h[4];
 501         low = s->plane[plane].l_h[0];
 502         low_stride = s->plane[plane].band[0][0].a_width;
 503         high = s->plane[plane].l_h[1];
 504         high_stride = s->plane[plane].band[0][0].a_width;
 505
 506         if (avctx->pix_fmt != AV_PIX_FMT_YUV422P10) {
 507             for (int i = 0; i < height * 2; i++) {
 508                 for (int j = 0; j < width * 2; j++)
 509                     input[j] /= 4;
 510                 input += a_width * 2;
 511             }
 512         }
 513
 514         input = s->plane[plane].l_h[4];
 515         for (int i = 0; i < height * 2; i++) {
 516             horiz_filter(input, low, high, width * 2);
 517             input += a_width * 2;
 518             low += low_stride;
 519             high += high_stride;
 520         }
 521
 522         low = s->plane[plane].subband[1];
 523         high = s->plane[plane].subband[3];
 524         input = s->plane[plane].l_h[1];
 525
 526         for (int i = 0; i < width; i++) {
 527             vert_filter(input, a_width, low, low_stride, high, high_stride, height * 2);
 528             input++;
 529             low++;
 530             high++;
 531         }
 532
 533         low = s->plane[plane].subband[0];
 534         high = s->plane[plane].subband[2];
 535         input = s->plane[plane].l_h[0];
 536
 537         for (int i = 0; i < width; i++) {
 538             vert_filter(input, a_width, low, low_stride, high, high_stride, height * 2);
 539             input++;
 540             low++;
 541             high++;
 542         }
 543     }
 544
 545     ret = ff_alloc_packet2(avctx, pkt, 64LL + s->planes * (2LL * avctx->width * avctx->height + 1000LL), 0);
 546     if (ret < 0)
 547         return ret;
 548
 549     bytestream2_init_writer(pby, pkt->data, pkt->size);
 550
 551     bytestream2_put_be16(pby, SampleType);
 552     bytestream2_put_be16(pby, 9);
 553
 554     bytestream2_put_be16(pby, SampleIndexTable);
 555     bytestream2_put_be16(pby, s->planes);
 556
 557     for (int i = 0; i < s->planes; i++)
 558         bytestream2_put_be32(pby, 0);
 559
 560     bytestream2_put_be16(pby, TransformType);
 561     bytestream2_put_be16(pby, 0);
 562
 563     bytestream2_put_be16(pby, NumFrames);
 564     bytestream2_put_be16(pby, 1);
 565
 566     bytestream2_put_be16(pby, ChannelCount);
 567     bytestream2_put_be16(pby, s->planes);
 568
 569     bytestream2_put_be16(pby, EncodedFormat);
 570     bytestream2_put_be16(pby, avctx->pix_fmt == AV_PIX_FMT_YUV422P10 ? 1 : 3);
 571
 572     bytestream2_put_be16(pby, WaveletCount);
 573     bytestream2_put_be16(pby, 3);
 574
 575     bytestream2_put_be16(pby, SubbandCount);
 576     bytestream2_put_be16(pby, SUBBAND_COUNT);
 577
 578     bytestream2_put_be16(pby, NumSpatial);
 579     bytestream2_put_be16(pby, 2);
 580
 581     bytestream2_put_be16(pby, FirstWavelet);
 582     bytestream2_put_be16(pby, 3);
 583
 584     bytestream2_put_be16(pby, ImageWidth);
 585     bytestream2_put_be16(pby, avctx->width);
 586
 587     bytestream2_put_be16(pby, ImageHeight);
 588     bytestream2_put_be16(pby, avctx->height);
 589
 590     bytestream2_put_be16(pby, -FrameNumber);
 591     bytestream2_put_be16(pby, avctx->frame_number);
 592
 593     bytestream2_put_be16(pby, Precision);
 594     bytestream2_put_be16(pby, avctx->pix_fmt == AV_PIX_FMT_YUV422P10 ? 10 : 12);
 595
 596     bytestream2_put_be16(pby, PrescaleTable);
 597     bytestream2_put_be16(pby, avctx->pix_fmt == AV_PIX_FMT_YUV422P10 ? 0x2000 : 0x2800);
 598
 599     bytestream2_put_be16(pby, SampleFlags);
 600     bytestream2_put_be16(pby, 1);
 601
 602     for (int p = 0; p < s->planes; p++) {
 603         int width = s->plane[p].band[0][0].width;
 604         int a_width = s->plane[p].band[0][0].a_width;
 605         int height = s->plane[p].band[0][0].height;
 606         int16_t *data = s->plane[p].subband[0];
 607
 608         if (p) {
 609             bytestream2_put_be16(pby, SampleType);
 610             bytestream2_put_be16(pby, 3);
 611
 612             bytestream2_put_be16(pby, ChannelNumber);
 613             bytestream2_put_be16(pby, p);
 614         }
 615
 616         bytestream2_put_be16(pby, BitstreamMarker);
 617         bytestream2_put_be16(pby, 0x1a4a);
 618
 619         pos = bytestream2_tell_p(pby);
 620
 621         bytestream2_put_be16(pby, LowpassSubband);
 622         bytestream2_put_be16(pby, 0);
 623
 624         bytestream2_put_be16(pby, NumLevels);
 625         bytestream2_put_be16(pby, 3);
 626
 627         bytestream2_put_be16(pby, LowpassWidth);
 628         bytestream2_put_be16(pby, width);
 629
 630         bytestream2_put_be16(pby, LowpassHeight);
 631         bytestream2_put_be16(pby, height);
 632
 633         bytestream2_put_be16(pby, PixelOffset);
 634         bytestream2_put_be16(pby, 0);
 635
 636         bytestream2_put_be16(pby, LowpassQuantization);
 637         bytestream2_put_be16(pby, 1);
 638
 639         bytestream2_put_be16(pby, LowpassPrecision);
 640         bytestream2_put_be16(pby, 16);
 641
 642         bytestream2_put_be16(pby, BitstreamMarker);
 643         bytestream2_put_be16(pby, 0x0f0f);
 644
 645         for (int i = 0; i < height; i++) {
 646             for (int j = 0; j < width; j++)
 647                 bytestream2_put_be16(pby, data[j]);
 648             data += a_width;
 649         }
 650
 651         bytestream2_put_be16(pby, BitstreamMarker);
 652         bytestream2_put_be16(pby, 0x1b4b);
 653
 654         for (int l = 0; l < 3; l++) {
 655             for (int i = 0; i < 3; i++) {
 656                 s->plane[p].quantization[1 + l * 3 + i] = quantization_per_subband[avctx->pix_fmt != AV_PIX_FMT_YUV422P10][p][s->compression][l * 3 + i];
 657             }
 658         }
 659
 660         for (int l = 0; l < 3; l++) {
 661             int a_width = s->plane[p].band[l][0].a_width;
 662             int width = s->plane[p].band[l][0].width;
 663             int stride = FFALIGN(width, 8);
 664             int height = s->plane[p].band[l][0].height;
 665
 666             bytestream2_put_be16(pby, BitstreamMarker);
 667             bytestream2_put_be16(pby, 0x0d0d);
 668
 669             bytestream2_put_be16(pby, WaveletType);
 670             bytestream2_put_be16(pby, 3 + 2 * (l == 2));
 671
 672             bytestream2_put_be16(pby, WaveletNumber);
 673             bytestream2_put_be16(pby, 3 - l);
 674
 675             bytestream2_put_be16(pby, WaveletLevel);
 676             bytestream2_put_be16(pby, 3 - l);
 677
 678             bytestream2_put_be16(pby, NumBands);
 679             bytestream2_put_be16(pby, 4);
 680
 681             bytestream2_put_be16(pby, HighpassWidth);
 682             bytestream2_put_be16(pby, width);
 683
 684             bytestream2_put_be16(pby, HighpassHeight);
 685             bytestream2_put_be16(pby, height);
 686
 687             bytestream2_put_be16(pby, LowpassBorder);
 688             bytestream2_put_be16(pby, 0);
 689
 690             bytestream2_put_be16(pby, HighpassBorder);
 691             bytestream2_put_be16(pby, 0);
 692
 693             bytestream2_put_be16(pby, LowpassScale);
 694             bytestream2_put_be16(pby, 1);
 695
 696             bytestream2_put_be16(pby, LowpassDivisor);
 697             bytestream2_put_be16(pby, 1);
 698
 699             for (int i = 0; i < 3; i++) {
 700                 int16_t *data = s->plane[p].subband[1 + l * 3 + i];
 701                 int count = 0, padd = 0;
 702
 703                 bytestream2_put_be16(pby, BitstreamMarker);
 704                 bytestream2_put_be16(pby, 0x0e0e);
 705
 706                 bytestream2_put_be16(pby, SubbandNumber);
 707                 bytestream2_put_be16(pby, i + 1);
 708
 709                 bytestream2_put_be16(pby, BandCodingFlags);
 710                 bytestream2_put_be16(pby, 2);
 711
 712                 bytestream2_put_be16(pby, BandWidth);
 713                 bytestream2_put_be16(pby, width);
 714
 715                 bytestream2_put_be16(pby, BandHeight);
 716                 bytestream2_put_be16(pby, height);
 717
 718                 bytestream2_put_be16(pby, SubbandBand);
 719                 bytestream2_put_be16(pby, 1 + l * 3 + i);
 720
 721                 bytestream2_put_be16(pby, BandEncoding);
 722                 bytestream2_put_be16(pby, 3);
 723
 724                 bytestream2_put_be16(pby, Quantization);
 725                 bytestream2_put_be16(pby, s->plane[p].quantization[1 + l * 3 + i]);
 726
 727                 bytestream2_put_be16(pby, BandScale);
 728                 bytestream2_put_be16(pby, 1);
 729
 730                 bytestream2_put_be16(pby, BandHeader);
 731                 bytestream2_put_be16(pby, 0);
 732
 733                 quantize_band(data, width, a_width, height,
 734                               s->plane[p].quantization[1 + l * 3 + i]);
 735
 736                 init_put_bits(pb, pkt->data + bytestream2_tell_p(pby), bytestream2_get_bytes_left_p(pby));
 737
 738                 for (int m = 0; m < height; m++) {
 739                     for (int j = 0; j < stride; j++) {
 740                         int16_t index = data[j];
 741
 742                         if (index < 0)
 743                             index += 512;
 744                         if (index == 0) {
 745                             count++;
 746                             continue;
 747                         } else if (count > 0) {
 748                             count = put_runcode(pb, count, rb);
 749                         }
 750
 751                         put_bits(pb, cb[index].size, cb[index].bits);
 752                     }
 753
 754                     data += a_width;
 755                 }
 756
 757                 if (count > 0) {
 758                     count = put_runcode(pb, count, rb);
 759                 }
 760
 761                 put_bits(pb, cb[512].size, cb[512].bits);
 762
 763                 flush_put_bits(pb);
 764                 bytestream2_skip_p(pby, put_bits_count(pb) >> 3);
 765                 padd = (4 - (bytestream2_tell_p(pby) & 3)) & 3;
 766                 while (padd--)
 767                     bytestream2_put_byte(pby, 0);
 768
 769                 bytestream2_put_be16(pby, BandTrailer);
 770                 bytestream2_put_be16(pby, 0);
 771             }
 772
 773             bytestream2_put_be16(pby, BitstreamMarker);
 774             bytestream2_put_be16(pby, 0x0c0c);
 775         }
 776
 777         s->plane[p].size = bytestream2_tell_p(pby) - pos;
 778     }
 779
 780     bytestream2_put_be16(pby, GroupTrailer);
 781     bytestream2_put_be16(pby, 0);
 782
 783     av_shrink_packet(pkt, bytestream2_tell_p(pby));
 784
 785     pkt->flags |= AV_PKT_FLAG_KEY;
 786
 787     bytestream2_seek_p(pby, 8, SEEK_SET);
 788     for (int i = 0; i < s->planes; i++)
 789         bytestream2_put_be32(pby, s->plane[i].size);
 790
 791     *got_packet = 1;
 792
 793     return 0;
 794 }
 795
 796 static av_cold int cfhd_encode_close(AVCodecContext *avctx)
 797 {
 798     CFHDEncContext *s = avctx->priv_data;
 799
 800     for (int i = 0; i < s->planes; i++) {
 801         av_freep(&s->plane[i].dwt_buf);
 802         av_freep(&s->plane[i].dwt_tmp);
 803
 804         for (int j = 0; j < SUBBAND_COUNT; j++)
 805             s->plane[i].subband[j] = NULL;
 806
 807         for (int j = 0; j < 8; j++)
 808             s->plane[i].l_h[j] = NULL;
 809     }
 810
 811     return 0;
 812 }
 813
 814 AVCodec ff_cfhd_encoder = {
 815     .name             = "cfhd",
 816     .long_name        = NULL_IF_CONFIG_SMALL("Cineform HD"),
 817     .type             = AVMEDIA_TYPE_VIDEO,
 818     .id               = AV_CODEC_ID_CFHD,
 819     .priv_data_size   = sizeof(CFHDEncContext),
 820     .init             = cfhd_encode_init,
 821     .close            = cfhd_encode_close,
 822     .encode2          = cfhd_encode_frame,
 823     .capabilities     = AV_CODEC_CAP_FRAME_THREADS,
 824     .pix_fmts         = (const enum AVPixelFormat[]) {
 825                           AV_PIX_FMT_YUV422P10,
 826                           AV_PIX_FMT_GBRP12,
 827                           AV_PIX_FMT_NONE
 828                         },
 829 };