falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
98671 Commits
32 Branches
1.0GB
Tree: 8d48e8d251
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '8d48e8d251'
${ noResults }
FFmpeg/libavcodec/cfhdenc.c

881 lines
34KB
Raw Blame History 

  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][13][9] = {

  107.     {{

  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

  121.     },

  122.     {

  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, },

  136.     },

  137.     {

  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, },

  151.     }},

  152.     {{

  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, },

  166.     },

  167.     {

  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, },

  181.     },

  182.     {

  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, },

  196.     }},

  197. };

  198. 

  199. typedef struct Codebook {

  200.     unsigned bits;

  201.     unsigned size;

  202. } Codebook;

  203. 

  204. typedef struct Runbook {

  205.     unsigned size;

  206.     unsigned bits;

  207.     unsigned run;

  208. } Runbook;

  209. 

  210. typedef struct PlaneEnc {

  211.     unsigned size;

  212. 

  213.     int16_t *dwt_buf;

  214.     int16_t *dwt_tmp;

  215. 

  216.     unsigned quantization[SUBBAND_COUNT];

  217.     int16_t *subband[SUBBAND_COUNT];

  218.     int16_t *l_h[8];

  219. 

  220.     SubBand band[DWT_LEVELS][4];

  221. } PlaneEnc;

  222. 

  223. typedef struct CFHDEncContext {

  224.     const AVClass *class;

  225. 

  226.     PutBitContext       pb;

  227.     PutByteContext      pby;

  228. 

  229.     int quality;

  230.     int planes;

  231.     int chroma_h_shift;

  232.     int chroma_v_shift;

  233.     PlaneEnc plane[4];

  234. 

  235.     uint16_t lut[1024];

  236.     Runbook  rb[321];

  237.     Codebook cb[513];

  238. } CFHDEncContext;

  239. 

  240. static av_cold int cfhd_encode_init(AVCodecContext *avctx)

  241. {

  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;

  246.     int ret, last = 0;

  247. 

  248.     ret = av_pix_fmt_get_chroma_sub_sample(avctx->pix_fmt,

  249.                                            &s->chroma_h_shift,

  250.                                            &s->chroma_v_shift);

  251.     if (ret < 0)

  252.         return ret;

  253. 

  254.     if (avctx->width & 15) {

  255.         av_log(avctx, AV_LOG_ERROR, "Width must be multiple of 16.\n");

  256.         return AVERROR_INVALIDDATA;

  257.     }

  258. 

  259.     s->planes = av_pix_fmt_count_planes(avctx->pix_fmt);

  260. 

  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;

  267. 

  268.         w8 = FFALIGN(width / 8, 8);

  269.         h8 = height / 8;

  270.         w4 = w8 * 2;

  271.         h4 = h8 * 2;

  272.         w2 = w4 * 2;

  273.         h2 = h4 * 2;

  274. 

  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);

  281. 

  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;

  292. 

  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;

  299.             }

  300.         }

  301. 

  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;

  311.     }

  312. 

  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);

  316. 

  317.         if (mag) {

  318.             s->cb[i].bits = (codebook[mag][1] << 1) | (value > 0 ? 0 : 1);

  319.             s->cb[i].size = codebook[mag][0] + 1;

  320.         } else {

  321.             s->cb[i].bits = codebook[mag][1];

  322.             s->cb[i].size = codebook[mag][0];

  323.         }

  324.     }

  325. 

  326.     s->cb[512].bits = 0x3114ba3;

  327.     s->cb[512].size = 26;

  328. 

  329.     s->rb[0].run = 0;

  330. 

  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];

  334. 

  335.         while (i < end) {

  336.             s->rb[i].run = run;

  337.             s->rb[i].bits = runbook[j][1];

  338.             s->rb[i++].size = runbook[j][0];

  339.         }

  340.     }

  341. 

  342.     s->rb[320].bits = runbook[7][1];

  343.     s->rb[320].size = runbook[7][0];

  344.     s->rb[320].run = 320;

  345. 

  346.     for (int i = 0; i < 256; i++) {

  347.         int idx = i + ((768LL * i * i * i) / (256 * 256 * 256));

  348. 

  349.         s->lut[idx] = i;

  350.     }

  351.     for (int i = 0; i < 1024; i++) {

  352.         if (s->lut[i])

  353.             last = s->lut[i];

  354.         else

  355.             s->lut[i] = last;

  356.     }

  357. 

  358.     return 0;

  359. }

  360. 

  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,

  364.                           int len)

  365. {

  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);

  370. 

  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]);

  376.     }

  377. 

  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);

  382. }

  383. 

  384. static void horiz_filter(int16_t *input, int16_t *low, int16_t *high,

  385.                          int width)

  386. {

  387.     filter(input, 1, low, 1, high, 1, width);

  388. }

  389. 

  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)

  393. {

  394.     filter(input, in_stride, low, low_stride, high, high_stride, len);

  395. }

  396. 

  397. static void quantize_band(int16_t *input, int width, int a_width,

  398.                           int height, unsigned quantization)

  399. {

  400.     const int factor = (1 << 16) / quantization;

  401. 

  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);

  405.         input += a_width;

  406.     }

  407. }

  408. 

  409. static int put_runcode(PutBitContext *pb, int count, const Runbook *const rb)

  410. {

  411.     while (count > 0) {

  412.         const int index = FFMIN(320, count);

  413. 

  414.         put_bits(pb, rb[index].size, rb[index].bits);

  415.         count -= rb[index].run;

  416.     }

  417. 

  418.     return 0;

  419. }

  420. 

  421. static int cfhd_encode_frame(AVCodecContext *avctx, AVPacket *pkt,

  422.                              const AVFrame *frame, int *got_packet)

  423. {

  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;

  430.     unsigned pos;

  431.     int ret = 0;

  432. 

  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;

  443. 

  444.         for (int i = 0; i < height * 2; i++) {

  445.             horiz_filter(input, low, high, width * 2);

  446.             input += in_stride;

  447.             low += a_width;

  448.             high += a_width;

  449.         }

  450. 

  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;

  456. 

  457.         for (int i = 0; i < width; i++) {

  458.             vert_filter(input, a_width, low, low_stride, high, high_stride, height * 2);

  459.             input++;

  460.             low++;

  461.             high++;

  462.         }

  463. 

  464.         input = s->plane[plane].l_h[6];

  465.         low = s->plane[plane].l_h[7];

  466.         high = s->plane[plane].subband[8];

  467. 

  468.         for (int i = 0; i < width; i++) {

  469.             vert_filter(input, a_width, low, low_stride, high, high_stride, height * 2);

  470.             input++;

  471.             low++;

  472.             high++;

  473.         }

  474. 

  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;

  483. 

  484.         for (int i = 0; i < height * 2; i++) {

  485.             for (int j = 0; j < width * 2; j++)

  486.                 input[j] /= 4;

  487.             input += a_width * 2;

  488.         }

  489. 

  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;

  494.             low += low_stride;

  495.             high += high_stride;

  496.         }

  497. 

  498.         input = s->plane[plane].l_h[4];

  499.         low = s->plane[plane].subband[4];

  500.         high = s->plane[plane].subband[6];

  501. 

  502.         for (int i = 0; i < width; i++) {

  503.             vert_filter(input, a_width, low, low_stride, high, high_stride, height * 2);

  504.             input++;

  505.             low++;

  506.             high++;

  507.         }

  508. 

  509.         input = s->plane[plane].l_h[3];

  510.         low = s->plane[plane].l_h[4];

  511.         high = s->plane[plane].subband[5];

  512. 

  513.         for (int i = 0; i < width; i++) {

  514.             vert_filter(input, a_width, low, low_stride, high, high_stride, height * 2);

  515.             input++;

  516.             low++;

  517.             high++;

  518.         }

  519. 

  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;

  528. 

  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++)

  532.                     input[j] /= 4;

  533.                 input += a_width * 2;

  534.             }

  535.         }

  536. 

  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;

  541.             low += low_stride;

  542.             high += high_stride;

  543.         }

  544. 

  545.         low = s->plane[plane].subband[1];

  546.         high = s->plane[plane].subband[3];

  547.         input = s->plane[plane].l_h[1];

  548. 

  549.         for (int i = 0; i < width; i++) {

  550.             vert_filter(input, a_width, low, low_stride, high, high_stride, height * 2);

  551.             input++;

  552.             low++;

  553.             high++;

  554.         }

  555. 

  556.         low = s->plane[plane].subband[0];

  557.         high = s->plane[plane].subband[2];

  558.         input = s->plane[plane].l_h[0];

  559. 

  560.         for (int i = 0; i < width; i++) {

  561.             vert_filter(input, a_width, low, low_stride, high, high_stride, height * 2);

  562.             input++;

  563.             low++;

  564.             high++;

  565.         }

  566.     }

  567. 

  568.     ret = ff_alloc_packet2(avctx, pkt, 64LL + s->planes * (2LL * avctx->width * avctx->height + 1000LL), 0);

  569.     if (ret < 0)

  570.         return ret;

  571. 

  572.     bytestream2_init_writer(pby, pkt->data, pkt->size);

  573. 

  574.     bytestream2_put_be16(pby, SampleType);

  575.     bytestream2_put_be16(pby, 9);

  576. 

  577.     bytestream2_put_be16(pby, SampleIndexTable);

  578.     bytestream2_put_be16(pby, s->planes);

  579. 

  580.     for (int i = 0; i < s->planes; i++)

  581.         bytestream2_put_be32(pby, 0);

  582. 

  583.     bytestream2_put_be16(pby, TransformType);

  584.     bytestream2_put_be16(pby, 0);

  585. 

  586.     bytestream2_put_be16(pby, NumFrames);

  587.     bytestream2_put_be16(pby, 1);

  588. 

  589.     bytestream2_put_be16(pby, ChannelCount);

  590.     bytestream2_put_be16(pby, s->planes);

  591. 

  592.     bytestream2_put_be16(pby, EncodedFormat);

  593.     bytestream2_put_be16(pby, avctx->pix_fmt == AV_PIX_FMT_YUV422P10 ? 1 : 3);

  594. 

  595.     bytestream2_put_be16(pby, WaveletCount);

  596.     bytestream2_put_be16(pby, 3);

  597. 

  598.     bytestream2_put_be16(pby, SubbandCount);

  599.     bytestream2_put_be16(pby, SUBBAND_COUNT);

  600. 

  601.     bytestream2_put_be16(pby, NumSpatial);

  602.     bytestream2_put_be16(pby, 2);

  603. 

  604.     bytestream2_put_be16(pby, FirstWavelet);

  605.     bytestream2_put_be16(pby, 3);

  606. 

  607.     bytestream2_put_be16(pby, ImageWidth);

  608.     bytestream2_put_be16(pby, avctx->width);

  609. 

  610.     bytestream2_put_be16(pby, ImageHeight);

  611.     bytestream2_put_be16(pby, avctx->height);

  612. 

  613.     bytestream2_put_be16(pby, -FrameNumber);

  614.     bytestream2_put_be16(pby, avctx->frame_number);

  615. 

  616.     bytestream2_put_be16(pby, Precision);

  617.     bytestream2_put_be16(pby, avctx->pix_fmt == AV_PIX_FMT_YUV422P10 ? 10 : 12);

  618. 

  619.     bytestream2_put_be16(pby, PrescaleTable);

  620.     bytestream2_put_be16(pby, avctx->pix_fmt == AV_PIX_FMT_YUV422P10 ? 0x2000 : 0x2800);

  621. 

  622.     bytestream2_put_be16(pby, SampleFlags);

  623.     bytestream2_put_be16(pby, 1);

  624. 

  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];

  630. 

  631.         if (p) {

  632.             bytestream2_put_be16(pby, SampleType);

  633.             bytestream2_put_be16(pby, 3);

  634. 

  635.             bytestream2_put_be16(pby, ChannelNumber);

  636.             bytestream2_put_be16(pby, p);

  637.         }

  638. 

  639.         bytestream2_put_be16(pby, BitstreamMarker);

  640.         bytestream2_put_be16(pby, 0x1a4a);

  641. 

  642.         pos = bytestream2_tell_p(pby);

  643. 

  644.         bytestream2_put_be16(pby, LowpassSubband);

  645.         bytestream2_put_be16(pby, 0);

  646. 

  647.         bytestream2_put_be16(pby, NumLevels);

  648.         bytestream2_put_be16(pby, 3);

  649. 

  650.         bytestream2_put_be16(pby, LowpassWidth);

  651.         bytestream2_put_be16(pby, width);

  652. 

  653.         bytestream2_put_be16(pby, LowpassHeight);

  654.         bytestream2_put_be16(pby, height);

  655. 

  656.         bytestream2_put_be16(pby, PixelOffset);

  657.         bytestream2_put_be16(pby, 0);

  658. 

  659.         bytestream2_put_be16(pby, LowpassQuantization);

  660.         bytestream2_put_be16(pby, 1);

  661. 

  662.         bytestream2_put_be16(pby, LowpassPrecision);

  663.         bytestream2_put_be16(pby, 16);

  664. 

  665.         bytestream2_put_be16(pby, BitstreamMarker);

  666.         bytestream2_put_be16(pby, 0x0f0f);

  667. 

  668.         for (int i = 0; i < height; i++) {

  669.             for (int j = 0; j < width; j++)

  670.                 bytestream2_put_be16(pby, data[j]);

  671.             data += a_width;

  672.         }

  673. 

  674.         bytestream2_put_be16(pby, BitstreamMarker);

  675.         bytestream2_put_be16(pby, 0x1b4b);

  676. 

  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];

  680.             }

  681.         }

  682. 

  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;

  688. 

  689.             bytestream2_put_be16(pby, BitstreamMarker);

  690.             bytestream2_put_be16(pby, 0x0d0d);

  691. 

  692.             bytestream2_put_be16(pby, WaveletType);

  693.             bytestream2_put_be16(pby, 3 + 2 * (l == 2));

  694. 

  695.             bytestream2_put_be16(pby, WaveletNumber);

  696.             bytestream2_put_be16(pby, 3 - l);

  697. 

  698.             bytestream2_put_be16(pby, WaveletLevel);

  699.             bytestream2_put_be16(pby, 3 - l);

  700. 

  701.             bytestream2_put_be16(pby, NumBands);

  702.             bytestream2_put_be16(pby, 4);

  703. 

  704.             bytestream2_put_be16(pby, HighpassWidth);

  705.             bytestream2_put_be16(pby, width);

  706. 

  707.             bytestream2_put_be16(pby, HighpassHeight);

  708.             bytestream2_put_be16(pby, height);

  709. 

  710.             bytestream2_put_be16(pby, LowpassBorder);

  711.             bytestream2_put_be16(pby, 0);

  712. 

  713.             bytestream2_put_be16(pby, HighpassBorder);

  714.             bytestream2_put_be16(pby, 0);

  715. 

  716.             bytestream2_put_be16(pby, LowpassScale);

  717.             bytestream2_put_be16(pby, 1);

  718. 

  719.             bytestream2_put_be16(pby, LowpassDivisor);

  720.             bytestream2_put_be16(pby, 1);

  721. 

  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;

  725. 

  726.                 bytestream2_put_be16(pby, BitstreamMarker);

  727.                 bytestream2_put_be16(pby, 0x0e0e);

  728. 

  729.                 bytestream2_put_be16(pby, SubbandNumber);

  730.                 bytestream2_put_be16(pby, i + 1);

  731. 

  732.                 bytestream2_put_be16(pby, BandCodingFlags);

  733.                 bytestream2_put_be16(pby, 1);

  734. 

  735.                 bytestream2_put_be16(pby, BandWidth);

  736.                 bytestream2_put_be16(pby, width);

  737. 

  738.                 bytestream2_put_be16(pby, BandHeight);

  739.                 bytestream2_put_be16(pby, height);

  740. 

  741.                 bytestream2_put_be16(pby, SubbandBand);

  742.                 bytestream2_put_be16(pby, 1 + l * 3 + i);

  743. 

  744.                 bytestream2_put_be16(pby, BandEncoding);

  745.                 bytestream2_put_be16(pby, 3);

  746. 

  747.                 bytestream2_put_be16(pby, Quantization);

  748.                 bytestream2_put_be16(pby, s->plane[p].quantization[1 + l * 3 + i]);

  749. 

  750.                 bytestream2_put_be16(pby, BandScale);

  751.                 bytestream2_put_be16(pby, 1);

  752. 

  753.                 bytestream2_put_be16(pby, BandHeader);

  754.                 bytestream2_put_be16(pby, 0);

  755. 

  756.                 quantize_band(data, width, a_width, height,

  757.                               s->plane[p].quantization[1 + l * 3 + i]);

  758. 

  759.                 init_put_bits(pb, pkt->data + bytestream2_tell_p(pby), bytestream2_get_bytes_left_p(pby));

  760. 

  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])];

  764. 

  765.                         if (index < 0)

  766.                             index += 512;

  767.                         if (index == 0) {

  768.                             count++;

  769.                             continue;

  770.                         } else if (count > 0) {

  771.                             count = put_runcode(pb, count, rb);

  772.                         }

  773. 

  774.                         put_bits(pb, cb[index].size, cb[index].bits);

  775.                     }

  776. 

  777.                     data += a_width;

  778.                 }

  779. 

  780.                 if (count > 0) {

  781.                     count = put_runcode(pb, count, rb);

  782.                 }

  783. 

  784.                 put_bits(pb, cb[512].size, cb[512].bits);

  785. 

  786.                 flush_put_bits(pb);

  787.                 bytestream2_skip_p(pby, put_bits_count(pb) >> 3);

  788.                 padd = (4 - (bytestream2_tell_p(pby) & 3)) & 3;

  789.                 while (padd--)

  790.                     bytestream2_put_byte(pby, 0);

  791. 

  792.                 bytestream2_put_be16(pby, BandTrailer);

  793.                 bytestream2_put_be16(pby, 0);

  794.             }

  795. 

  796.             bytestream2_put_be16(pby, BitstreamMarker);

  797.             bytestream2_put_be16(pby, 0x0c0c);

  798.         }

  799. 

  800.         s->plane[p].size = bytestream2_tell_p(pby) - pos;

  801.     }

  802. 

  803.     bytestream2_put_be16(pby, GroupTrailer);

  804.     bytestream2_put_be16(pby, 0);

  805. 

  806.     av_shrink_packet(pkt, bytestream2_tell_p(pby));

  807. 

  808.     pkt->flags |= AV_PKT_FLAG_KEY;

  809. 

  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);

  813. 

  814.     *got_packet = 1;

  815. 

  816.     return 0;

  817. }

  818. 

  819. static av_cold int cfhd_encode_close(AVCodecContext *avctx)

  820. {

  821.     CFHDEncContext *s = avctx->priv_data;

  822. 

  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);

  826. 

  827.         for (int j = 0; j < SUBBAND_COUNT; j++)

  828.             s->plane[i].subband[j] = NULL;

  829. 

  830.         for (int j = 0; j < 8; j++)

  831.             s->plane[i].l_h[j] = NULL;

  832.     }

  833. 

  834.     return 0;

  835. }

  836. 

  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" },

  854.     { NULL},

  855. };

  856. 

  857. static const AVClass cfhd_class = {

  858.     .class_name = "cfhd",

  859.     .item_name  = av_default_item_name,

  860.     .option     = options,

  861.     .version    = LIBAVUTIL_VERSION_INT,

  862. };

  863. 

  864. AVCodec ff_cfhd_encoder = {

  865.     .name             = "cfhd",

  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,

  877.                           AV_PIX_FMT_GBRP12,

  878.                           AV_PIX_FMT_NONE

  879.                         },

  880. };