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.
45418 Commits
32 Branches
511MB
Tree: efb0e4e7af
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'efb0e4e7af'
${ noResults }
FFmpeg/libavcodec/huffyuv.c

1572 lines
52KB
Raw Blame History 

  1. /*

  2.  * huffyuv codec for libavcodec

  3.  *

  4.  * Copyright (c) 2002-2003 Michael Niedermayer <michaelni@gmx.at>

  5.  *

  6.  * see http://www.pcisys.net/~melanson/codecs/huffyuv.txt for a description of

  7.  * the algorithm used

  8.  *

  9.  * This file is part of FFmpeg.

  10.  *

  11.  * FFmpeg is free software; you can redistribute it and/or

  12.  * modify it under the terms of the GNU Lesser General Public

  13.  * License as published by the Free Software Foundation; either

  14.  * version 2.1 of the License, or (at your option) any later version.

  15.  *

  16.  * FFmpeg is distributed in the hope that it will be useful,

  17.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  18.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

  19.  * Lesser General Public License for more details.

  20.  *

  21.  * You should have received a copy of the GNU Lesser General Public

  22.  * License along with FFmpeg; if not, write to the Free Software

  23.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

  24.  */

  25. 

  26. /**

  27.  * @file

  28.  * huffyuv codec for libavcodec.

  29.  */

  30. 

  31. #include "avcodec.h"

  32. #include "internal.h"

  33. #include "get_bits.h"

  34. #include "put_bits.h"

  35. #include "dsputil.h"

  36. #include "thread.h"

  37. #include "huffman.h"

  38. 

  39. #define VLC_BITS 11

  40. 

  41. #if HAVE_BIGENDIAN

  42. #define B 3

  43. #define G 2

  44. #define R 1

  45. #define A 0

  46. #else

  47. #define B 0

  48. #define G 1

  49. #define R 2

  50. #define A 3

  51. #endif

  52. 

  53. typedef enum Predictor {

  54.     LEFT= 0,

  55.     PLANE,

  56.     MEDIAN,

  57. } Predictor;

  58. 

  59. typedef struct HYuvContext {

  60.     AVCodecContext *avctx;

  61.     Predictor predictor;

  62.     GetBitContext gb;

  63.     PutBitContext pb;

  64.     int interlaced;

  65.     int decorrelate;

  66.     int bitstream_bpp;

  67.     int version;

  68.     int yuy2;                               //use yuy2 instead of 422P

  69.     int bgr32;                              //use bgr32 instead of bgr24

  70.     int width, height;

  71.     int flags;

  72.     int context;

  73.     int picture_number;

  74.     int last_slice_end;

  75.     uint8_t *temp[3];

  76.     uint64_t stats[3][256];

  77.     uint8_t len[3][256];

  78.     uint32_t bits[3][256];

  79.     uint32_t pix_bgr_map[1<<VLC_BITS];

  80.     VLC vlc[6];                             //Y,U,V,YY,YU,YV

  81.     AVFrame picture;

  82.     uint8_t *bitstream_buffer;

  83.     unsigned int bitstream_buffer_size;

  84.     DSPContext dsp;

  85. } HYuvContext;

  86. 

  87. #define classic_shift_luma_table_size 42

  88. static const unsigned char classic_shift_luma[classic_shift_luma_table_size + FF_INPUT_BUFFER_PADDING_SIZE] = {

  89.   34,36,35,69,135,232,9,16,10,24,11,23,12,16,13,10,14,8,15,8,

  90.   16,8,17,20,16,10,207,206,205,236,11,8,10,21,9,23,8,8,199,70,

  91.   69,68, 0,

  92.   0,0,0,0,0,0,0,0,

  93. };

  94. 

  95. #define classic_shift_chroma_table_size 59

  96. static const unsigned char classic_shift_chroma[classic_shift_chroma_table_size + FF_INPUT_BUFFER_PADDING_SIZE] = {

  97.   66,36,37,38,39,40,41,75,76,77,110,239,144,81,82,83,84,85,118,183,

  98.   56,57,88,89,56,89,154,57,58,57,26,141,57,56,58,57,58,57,184,119,

  99.   214,245,116,83,82,49,80,79,78,77,44,75,41,40,39,38,37,36,34, 0,

  100.   0,0,0,0,0,0,0,0,

  101. };

  102. 

  103. static const unsigned char classic_add_luma[256] = {

  104.     3,  9,  5, 12, 10, 35, 32, 29, 27, 50, 48, 45, 44, 41, 39, 37,

  105.    73, 70, 68, 65, 64, 61, 58, 56, 53, 50, 49, 46, 44, 41, 38, 36,

  106.    68, 65, 63, 61, 58, 55, 53, 51, 48, 46, 45, 43, 41, 39, 38, 36,

  107.    35, 33, 32, 30, 29, 27, 26, 25, 48, 47, 46, 44, 43, 41, 40, 39,

  108.    37, 36, 35, 34, 32, 31, 30, 28, 27, 26, 24, 23, 22, 20, 19, 37,

  109.    35, 34, 33, 31, 30, 29, 27, 26, 24, 23, 21, 20, 18, 17, 15, 29,

  110.    27, 26, 24, 22, 21, 19, 17, 16, 14, 26, 25, 23, 21, 19, 18, 16,

  111.    15, 27, 25, 23, 21, 19, 17, 16, 14, 26, 25, 23, 21, 18, 17, 14,

  112.    12, 17, 19, 13,  4,  9,  2, 11,  1,  7,  8,  0, 16,  3, 14,  6,

  113.    12, 10,  5, 15, 18, 11, 10, 13, 15, 16, 19, 20, 22, 24, 27, 15,

  114.    18, 20, 22, 24, 26, 14, 17, 20, 22, 24, 27, 15, 18, 20, 23, 25,

  115.    28, 16, 19, 22, 25, 28, 32, 36, 21, 25, 29, 33, 38, 42, 45, 49,

  116.    28, 31, 34, 37, 40, 42, 44, 47, 49, 50, 52, 54, 56, 57, 59, 60,

  117.    62, 64, 66, 67, 69, 35, 37, 39, 40, 42, 43, 45, 47, 48, 51, 52,

  118.    54, 55, 57, 59, 60, 62, 63, 66, 67, 69, 71, 72, 38, 40, 42, 43,

  119.    46, 47, 49, 51, 26, 28, 30, 31, 33, 34, 18, 19, 11, 13,  7,  8,

  120. };

  121. 

  122. static const unsigned char classic_add_chroma[256] = {

  123.     3,  1,  2,  2,  2,  2,  3,  3,  7,  5,  7,  5,  8,  6, 11,  9,

  124.     7, 13, 11, 10,  9,  8,  7,  5,  9,  7,  6,  4,  7,  5,  8,  7,

  125.    11,  8, 13, 11, 19, 15, 22, 23, 20, 33, 32, 28, 27, 29, 51, 77,

  126.    43, 45, 76, 81, 46, 82, 75, 55, 56,144, 58, 80, 60, 74,147, 63,

  127.   143, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,

  128.    80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 27, 30, 21, 22,

  129.    17, 14,  5,  6,100, 54, 47, 50, 51, 53,106,107,108,109,110,111,

  130.   112,113,114,115,  4,117,118, 92, 94,121,122,  3,124,103,  2,  1,

  131.     0,129,130,131,120,119,126,125,136,137,138,139,140,141,142,134,

  132.   135,132,133,104, 64,101, 62, 57,102, 95, 93, 59, 61, 28, 97, 96,

  133.    52, 49, 48, 29, 32, 25, 24, 46, 23, 98, 45, 44, 43, 20, 42, 41,

  134.    19, 18, 99, 40, 15, 39, 38, 16, 13, 12, 11, 37, 10,  9,  8, 36,

  135.     7,128,127,105,123,116, 35, 34, 33,145, 31, 79, 42,146, 78, 26,

  136.    83, 48, 49, 50, 44, 47, 26, 31, 30, 18, 17, 19, 21, 24, 25, 13,

  137.    14, 16, 17, 18, 20, 21, 12, 14, 15,  9, 10,  6,  9,  6,  5,  8,

  138.     6, 12,  8, 10,  7,  9,  6,  4,  6,  2,  2,  3,  3,  3,  3,  2,

  139. };

  140. 

  141. static inline int sub_left_prediction(HYuvContext *s, uint8_t *dst,

  142.                                       const uint8_t *src, int w, int left)

  143. {

  144.     int i;

  145.     if (w < 32) {

  146.         for (i = 0; i < w; i++) {

  147.             const int temp = src[i];

  148.             dst[i] = temp - left;

  149.             left   = temp;

  150.         }

  151.         return left;

  152.     } else {

  153.         for (i = 0; i < 16; i++) {

  154.             const int temp = src[i];

  155.             dst[i] = temp - left;

  156.             left   = temp;

  157.         }

  158.         s->dsp.diff_bytes(dst + 16, src + 16, src + 15, w - 16);

  159.         return src[w-1];

  160.     }

  161. }

  162. 

  163. static inline void sub_left_prediction_bgr32(HYuvContext *s, uint8_t *dst,

  164.                                              const uint8_t *src, int w,

  165.                                              int *red, int *green, int *blue, int *alpha)

  166. {

  167.     int i;

  168.     int r,g,b,a;

  169.     r = *red;

  170.     g = *green;

  171.     b = *blue;

  172.     a = *alpha;

  173.     for (i = 0; i < FFMIN(w, 4); i++) {

  174.         const int rt = src[i * 4 + R];

  175.         const int gt = src[i * 4 + G];

  176.         const int bt = src[i * 4 + B];

  177.         const int at = src[i * 4 + A];

  178.         dst[i * 4 + R] = rt - r;

  179.         dst[i * 4 + G] = gt - g;

  180.         dst[i * 4 + B] = bt - b;

  181.         dst[i * 4 + A] = at - a;

  182.         r = rt;

  183.         g = gt;

  184.         b = bt;

  185.         a = at;

  186.     }

  187. 

  188.     s->dsp.diff_bytes(dst + 16, src + 16, src + 12, w * 4 - 16);

  189. 

  190.     *red   = src[(w - 1) * 4 + R];

  191.     *green = src[(w - 1) * 4 + G];

  192.     *blue  = src[(w - 1) * 4 + B];

  193.     *alpha = src[(w - 1) * 4 + A];

  194. }

  195. 

  196. static inline void sub_left_prediction_rgb24(HYuvContext *s, uint8_t *dst, const uint8_t *src, int w, int *red, int *green, int *blue){

  197.     int i;

  198.     int r,g,b;

  199.     r = *red;

  200.     g = *green;

  201.     b = *blue;

  202.     for (i = 0; i < FFMIN(w,16); i++) {

  203.         const int rt = src[i*3 + 0];

  204.         const int gt = src[i*3 + 1];

  205.         const int bt = src[i*3 + 2];

  206.         dst[i*3 + 0] = rt - r;

  207.         dst[i*3 + 1] = gt - g;

  208.         dst[i*3 + 2] = bt - b;

  209.         r = rt;

  210.         g = gt;

  211.         b = bt;

  212.     }

  213. 

  214.     s->dsp.diff_bytes(dst + 48, src + 48, src + 48 - 3, w*3 - 48);

  215. 

  216.     *red   = src[(w - 1)*3 + 0];

  217.     *green = src[(w - 1)*3 + 1];

  218.     *blue  = src[(w - 1)*3 + 2];

  219. }

  220. 

  221. static int read_len_table(uint8_t *dst, GetBitContext *gb)

  222. {

  223.     int i, val, repeat;

  224. 

  225.     for (i = 0; i < 256;) {

  226.         repeat = get_bits(gb, 3);

  227.         val    = get_bits(gb, 5);

  228.         if (repeat == 0)

  229.             repeat = get_bits(gb, 8);

  230.         if (i + repeat > 256 || get_bits_left(gb) < 0) {

  231.             av_log(NULL, AV_LOG_ERROR, "Error reading huffman table\n");

  232.             return -1;

  233.         }

  234.         while (repeat--)

  235.             dst[i++] = val;

  236.     }

  237.     return 0;

  238. }

  239. 

  240. static int generate_bits_table(uint32_t *dst, const uint8_t *len_table)

  241. {

  242.     int len, index;

  243.     uint32_t bits = 0;

  244. 

  245.     for (len = 32; len > 0; len--) {

  246.         for (index = 0; index < 256; index++) {

  247.             if (len_table[index] == len)

  248.                 dst[index] = bits++;

  249.         }

  250.         if (bits & 1) {

  251.             av_log(NULL, AV_LOG_ERROR, "Error generating huffman table\n");

  252.             return -1;

  253.         }

  254.         bits >>= 1;

  255.     }

  256.     return 0;

  257. }

  258. 

  259. static void generate_joint_tables(HYuvContext *s)

  260. {

  261.     uint16_t symbols[1 << VLC_BITS];

  262.     uint16_t bits[1 << VLC_BITS];

  263.     uint8_t len[1 << VLC_BITS];

  264.     if (s->bitstream_bpp < 24) {

  265.         int p, i, y, u;

  266.         for (p = 0; p < 3; p++) {

  267.             for (i = y = 0; y < 256; y++) {

  268.                 int len0 = s->len[0][y];

  269.                 int limit = VLC_BITS - len0;

  270.                 if(limit <= 0)

  271.                     continue;

  272.                 for (u = 0; u < 256; u++) {

  273.                     int len1 = s->len[p][u];

  274.                     if (len1 > limit)

  275.                         continue;

  276.                     len[i] = len0 + len1;

  277.                     bits[i] = (s->bits[0][y] << len1) + s->bits[p][u];

  278.                     symbols[i] = (y << 8) + u;

  279.                     if(symbols[i] != 0xffff) // reserved to mean "invalid"

  280.                         i++;

  281.                 }

  282.             }

  283.             ff_free_vlc(&s->vlc[3 + p]);

  284.             ff_init_vlc_sparse(&s->vlc[3 + p], VLC_BITS, i, len, 1, 1,

  285.                                bits, 2, 2, symbols, 2, 2, 0);

  286.         }

  287.     } else {

  288.         uint8_t (*map)[4] = (uint8_t(*)[4])s->pix_bgr_map;

  289.         int i, b, g, r, code;

  290.         int p0 = s->decorrelate;

  291.         int p1 = !s->decorrelate;

  292.         // restrict the range to +/-16 because that's pretty much guaranteed to

  293.         // cover all the combinations that fit in 11 bits total, and it doesn't

  294.         // matter if we miss a few rare codes.

  295.         for (i = 0, g = -16; g < 16; g++) {

  296.             int len0 = s->len[p0][g & 255];

  297.             int limit0 = VLC_BITS - len0;

  298.             if (limit0 < 2)

  299.                 continue;

  300.             for (b = -16; b < 16; b++) {

  301.                 int len1 = s->len[p1][b & 255];

  302.                 int limit1 = limit0 - len1;

  303.                 if (limit1 < 1)

  304.                     continue;

  305.                 code = (s->bits[p0][g & 255] << len1) + s->bits[p1][b & 255];

  306.                 for (r = -16; r < 16; r++) {

  307.                     int len2 = s->len[2][r & 255];

  308.                     if (len2 > limit1)

  309.                         continue;

  310.                     len[i] = len0 + len1 + len2;

  311.                     bits[i] = (code << len2) + s->bits[2][r & 255];

  312.                     if (s->decorrelate) {

  313.                         map[i][G] = g;

  314.                         map[i][B] = g + b;

  315.                         map[i][R] = g + r;

  316.                     } else {

  317.                         map[i][B] = g;

  318.                         map[i][G] = b;

  319.                         map[i][R] = r;

  320.                     }

  321.                     i++;

  322.                 }

  323.             }

  324.         }

  325.         ff_free_vlc(&s->vlc[3]);

  326.         init_vlc(&s->vlc[3], VLC_BITS, i, len, 1, 1, bits, 2, 2, 0);

  327.     }

  328. }

  329. 

  330. static int read_huffman_tables(HYuvContext *s, const uint8_t *src, int length)

  331. {

  332.     GetBitContext gb;

  333.     int i;

  334. 

  335.     init_get_bits(&gb, src, length * 8);

  336. 

  337.     for (i = 0; i < 3; i++) {

  338.         if (read_len_table(s->len[i], &gb) < 0)

  339.             return -1;

  340.         if (generate_bits_table(s->bits[i], s->len[i]) < 0) {

  341.             return -1;

  342.         }

  343.         ff_free_vlc(&s->vlc[i]);

  344.         init_vlc(&s->vlc[i], VLC_BITS, 256, s->len[i], 1, 1,

  345.                  s->bits[i], 4, 4, 0);

  346.     }

  347. 

  348.     generate_joint_tables(s);

  349. 

  350.     return (get_bits_count(&gb) + 7) / 8;

  351. }

  352. 

  353. static int read_old_huffman_tables(HYuvContext *s)

  354. {

  355.     GetBitContext gb;

  356.     int i;

  357. 

  358.     init_get_bits(&gb, classic_shift_luma,

  359.                   classic_shift_luma_table_size * 8);

  360.     if (read_len_table(s->len[0], &gb) < 0)

  361.         return -1;

  362. 

  363.     init_get_bits(&gb, classic_shift_chroma,

  364.                   classic_shift_chroma_table_size * 8);

  365.     if (read_len_table(s->len[1], &gb) < 0)

  366.         return -1;

  367. 

  368.     for(i=0; i<256; i++) s->bits[0][i] = classic_add_luma  [i];

  369.     for(i=0; i<256; i++) s->bits[1][i] = classic_add_chroma[i];

  370. 

  371.     if (s->bitstream_bpp >= 24) {

  372.         memcpy(s->bits[1], s->bits[0], 256 * sizeof(uint32_t));

  373.         memcpy(s->len[1] , s->len [0], 256 * sizeof(uint8_t));

  374.     }

  375.     memcpy(s->bits[2], s->bits[1], 256 * sizeof(uint32_t));

  376.     memcpy(s->len[2] , s->len [1], 256 * sizeof(uint8_t));

  377. 

  378.     for (i = 0; i < 3; i++) {

  379.         ff_free_vlc(&s->vlc[i]);

  380.         init_vlc(&s->vlc[i], VLC_BITS, 256, s->len[i], 1, 1,

  381.                  s->bits[i], 4, 4, 0);

  382.     }

  383. 

  384.     generate_joint_tables(s);

  385. 

  386.     return 0;

  387. }

  388. 

  389. static av_cold void alloc_temp(HYuvContext *s)

  390. {

  391.     int i;

  392. 

  393.     if (s->bitstream_bpp<24) {

  394.         for (i=0; i<3; i++) {

  395.             s->temp[i]= av_malloc(s->width + 16);

  396.         }

  397.     } else {

  398.         s->temp[0]= av_mallocz(4*s->width + 16);

  399.     }

  400. }

  401. 

  402. static av_cold int common_init(AVCodecContext *avctx)

  403. {

  404.     HYuvContext *s = avctx->priv_data;

  405. 

  406.     s->avctx = avctx;

  407.     s->flags = avctx->flags;

  408. 

  409.     ff_dsputil_init(&s->dsp, avctx);

  410. 

  411.     s->width = avctx->width;

  412.     s->height = avctx->height;

  413.     av_assert1(s->width > 0 && s->height > 0);

  414. 

  415.     return 0;

  416. }

  417. 

  418. #if CONFIG_HUFFYUV_DECODER || CONFIG_FFVHUFF_DECODER

  419. static av_cold int decode_init(AVCodecContext *avctx)

  420. {

  421.     HYuvContext *s = avctx->priv_data;

  422. 

  423.     common_init(avctx);

  424.     memset(s->vlc, 0, 3 * sizeof(VLC));

  425. 

  426.     avctx->coded_frame = &s->picture;

  427.     avcodec_get_frame_defaults(&s->picture);

  428.     s->interlaced = s->height > 288;

  429. 

  430.     s->bgr32 = 1;

  431. 

  432.     if (avctx->extradata_size) {

  433.         if ((avctx->bits_per_coded_sample & 7) &&

  434.             avctx->bits_per_coded_sample != 12)

  435.             s->version = 1; // do such files exist at all?

  436.         else

  437.             s->version = 2;

  438.     } else

  439.         s->version = 0;

  440. 

  441.     if (s->version == 2) {

  442.         int method, interlace;

  443. 

  444.         if (avctx->extradata_size < 4)

  445.             return -1;

  446. 

  447.         method = ((uint8_t*)avctx->extradata)[0];

  448.         s->decorrelate = method & 64 ? 1 : 0;

  449.         s->predictor = method & 63;

  450.         s->bitstream_bpp = ((uint8_t*)avctx->extradata)[1];

  451.         if (s->bitstream_bpp == 0)

  452.             s->bitstream_bpp = avctx->bits_per_coded_sample & ~7;

  453.         interlace = (((uint8_t*)avctx->extradata)[2] & 0x30) >> 4;

  454.         s->interlaced = (interlace == 1) ? 1 : (interlace == 2) ? 0 : s->interlaced;

  455.         s->context = ((uint8_t*)avctx->extradata)[2] & 0x40 ? 1 : 0;

  456. 

  457.         if ( read_huffman_tables(s, ((uint8_t*)avctx->extradata) + 4,

  458.                                  avctx->extradata_size - 4) < 0)

  459.             return -1;

  460.     }else{

  461.         switch (avctx->bits_per_coded_sample & 7) {

  462.         case 1:

  463.             s->predictor = LEFT;

  464.             s->decorrelate = 0;

  465.             break;

  466.         case 2:

  467.             s->predictor = LEFT;

  468.             s->decorrelate = 1;

  469.             break;

  470.         case 3:

  471.             s->predictor = PLANE;

  472.             s->decorrelate = avctx->bits_per_coded_sample >= 24;

  473.             break;

  474.         case 4:

  475.             s->predictor = MEDIAN;

  476.             s->decorrelate = 0;

  477.             break;

  478.         default:

  479.             s->predictor = LEFT; //OLD

  480.             s->decorrelate = 0;

  481.             break;

  482.         }

  483.         s->bitstream_bpp = avctx->bits_per_coded_sample & ~7;

  484.         s->context = 0;

  485. 

  486.         if (read_old_huffman_tables(s) < 0)

  487.             return -1;

  488.     }

  489. 

  490.     switch (s->bitstream_bpp) {

  491.     case 12:

  492.         avctx->pix_fmt = AV_PIX_FMT_YUV420P;

  493.         break;

  494.     case 16:

  495.         if (s->yuy2) {

  496.             avctx->pix_fmt = AV_PIX_FMT_YUYV422;

  497.         } else {

  498.             avctx->pix_fmt = AV_PIX_FMT_YUV422P;

  499.         }

  500.         break;

  501.     case 24:

  502.     case 32:

  503.         if (s->bgr32) {

  504.             avctx->pix_fmt = AV_PIX_FMT_RGB32;

  505.         } else {

  506.             avctx->pix_fmt = AV_PIX_FMT_BGR24;

  507.         }

  508.         break;

  509.     default:

  510.         return AVERROR_INVALIDDATA;

  511.     }

  512. 

  513.     if ((avctx->pix_fmt == AV_PIX_FMT_YUV422P || avctx->pix_fmt == AV_PIX_FMT_YUV420P) && avctx->width & 1) {

  514.         av_log(avctx, AV_LOG_ERROR, "width must be even for this colorspace\n");

  515.         return AVERROR_INVALIDDATA;

  516.     }

  517. 

  518.     alloc_temp(s);

  519. 

  520.     return 0;

  521. }

  522. 

  523. static av_cold int decode_init_thread_copy(AVCodecContext *avctx)

  524. {

  525.     HYuvContext *s = avctx->priv_data;

  526.     int i;

  527. 

  528.     avctx->coded_frame= &s->picture;

  529.     alloc_temp(s);

  530. 

  531.     for (i = 0; i < 6; i++)

  532.         s->vlc[i].table = NULL;

  533. 

  534.     if (s->version == 2) {

  535.         if (read_huffman_tables(s, ((uint8_t*)avctx->extradata) + 4,

  536.                                 avctx->extradata_size) < 0)

  537.             return -1;

  538.     } else {

  539.         if (read_old_huffman_tables(s) < 0)

  540.             return -1;

  541.     }

  542. 

  543.     return 0;

  544. }

  545. #endif /* CONFIG_HUFFYUV_DECODER || CONFIG_FFVHUFF_DECODER */

  546. 

  547. #if CONFIG_HUFFYUV_ENCODER || CONFIG_FFVHUFF_ENCODER

  548. static int store_table(HYuvContext *s, const uint8_t *len, uint8_t *buf)

  549. {

  550.     int i;

  551.     int index = 0;

  552. 

  553.     for (i = 0; i < 256;) {

  554.         int val = len[i];

  555.         int repeat = 0;

  556. 

  557.         for (; i < 256 && len[i] == val && repeat < 255; i++)

  558.             repeat++;

  559. 

  560.         av_assert0(val < 32 && val >0 && repeat<256 && repeat>0);

  561.         if (repeat > 7) {

  562.             buf[index++] = val;

  563.             buf[index++] = repeat;

  564.         } else {

  565.             buf[index++] = val | (repeat << 5);

  566.         }

  567.     }

  568. 

  569.     return index;

  570. }

  571. 

  572. static av_cold int encode_init(AVCodecContext *avctx)

  573. {

  574.     HYuvContext *s = avctx->priv_data;

  575.     int i, j;

  576. 

  577.     common_init(avctx);

  578. 

  579.     avctx->extradata = av_mallocz(1024*30); // 256*3+4 == 772

  580.     avctx->stats_out = av_mallocz(1024*30); // 21*256*3(%llu ) + 3(\n) + 1(0) = 16132

  581.     s->version = 2;

  582. 

  583.     avctx->coded_frame = &s->picture;

  584. 

  585.     switch (avctx->pix_fmt) {

  586.     case AV_PIX_FMT_YUV420P:

  587.     case AV_PIX_FMT_YUV422P:

  588.         if (s->width & 1) {

  589.             av_log(avctx, AV_LOG_ERROR, "width must be even for this colorspace\n");

  590.             return AVERROR(EINVAL);

  591.         }

  592.         s->bitstream_bpp = avctx->pix_fmt == AV_PIX_FMT_YUV420P ? 12 : 16;

  593.         break;

  594.     case AV_PIX_FMT_RGB32:

  595.         s->bitstream_bpp = 32;

  596.         break;

  597.     case AV_PIX_FMT_RGB24:

  598.         s->bitstream_bpp = 24;

  599.         break;

  600.     default:

  601.         av_log(avctx, AV_LOG_ERROR, "format not supported\n");

  602.         return -1;

  603.     }

  604.     avctx->bits_per_coded_sample = s->bitstream_bpp;

  605.     s->decorrelate = s->bitstream_bpp >= 24;

  606.     s->predictor = avctx->prediction_method;

  607.     s->interlaced = avctx->flags&CODEC_FLAG_INTERLACED_ME ? 1 : 0;

  608.     if (avctx->context_model == 1) {

  609.         s->context = avctx->context_model;

  610.         if (s->flags & (CODEC_FLAG_PASS1|CODEC_FLAG_PASS2)) {

  611.             av_log(avctx, AV_LOG_ERROR,

  612.                    "context=1 is not compatible with "

  613.                    "2 pass huffyuv encoding\n");

  614.             return -1;

  615.         }

  616.     }else s->context= 0;

  617. 

  618.     if (avctx->codec->id == AV_CODEC_ID_HUFFYUV) {

  619.         if (avctx->pix_fmt == AV_PIX_FMT_YUV420P) {

  620.             av_log(avctx, AV_LOG_ERROR,

  621.                    "Error: YV12 is not supported by huffyuv; use "

  622.                    "vcodec=ffvhuff or format=422p\n");

  623.             return -1;

  624.         }

  625.         if (avctx->context_model) {

  626.             av_log(avctx, AV_LOG_ERROR,

  627.                    "Error: per-frame huffman tables are not supported "

  628.                    "by huffyuv; use vcodec=ffvhuff\n");

  629.             return -1;

  630.         }

  631.         if (s->interlaced != ( s->height > 288 ))

  632.             av_log(avctx, AV_LOG_INFO,

  633.                    "using huffyuv 2.2.0 or newer interlacing flag\n");

  634.     }

  635. 

  636.     if (s->bitstream_bpp >= 24 && s->predictor == MEDIAN) {

  637.         av_log(avctx, AV_LOG_ERROR,

  638.                "Error: RGB is incompatible with median predictor\n");

  639.         return -1;

  640.     }

  641. 

  642.     ((uint8_t*)avctx->extradata)[0] = s->predictor | (s->decorrelate << 6);

  643.     ((uint8_t*)avctx->extradata)[1] = s->bitstream_bpp;

  644.     ((uint8_t*)avctx->extradata)[2] = s->interlaced ? 0x10 : 0x20;

  645.     if (s->context)

  646.         ((uint8_t*)avctx->extradata)[2] |= 0x40;

  647.     ((uint8_t*)avctx->extradata)[3] = 0;

  648.     s->avctx->extradata_size = 4;

  649. 

  650.     if (avctx->stats_in) {

  651.         char *p = avctx->stats_in;

  652. 

  653.         for (i = 0; i < 3; i++)

  654.             for (j = 0; j < 256; j++)

  655.                 s->stats[i][j] = 1;

  656. 

  657.         for (;;) {

  658.             for (i = 0; i < 3; i++) {

  659.                 char *next;

  660. 

  661.                 for (j = 0; j < 256; j++) {

  662.                     s->stats[i][j] += strtol(p, &next, 0);

  663.                     if (next == p) return -1;

  664.                     p = next;

  665.                 }

  666.             }

  667.             if (p[0] == 0 || p[1] == 0 || p[2] == 0) break;

  668.         }

  669.     } else {

  670.         for (i = 0; i < 3; i++)

  671.             for (j = 0; j < 256; j++) {

  672.                 int d = FFMIN(j, 256 - j);

  673. 

  674.                 s->stats[i][j] = 100000000 / (d + 1);

  675.             }

  676.     }

  677. 

  678.     for (i = 0; i < 3; i++) {

  679.         ff_huff_gen_len_table(s->len[i], s->stats[i]);

  680. 

  681.         if (generate_bits_table(s->bits[i], s->len[i]) < 0) {

  682.             return -1;

  683.         }

  684. 

  685.         s->avctx->extradata_size +=

  686.             store_table(s, s->len[i], &((uint8_t*)s->avctx->extradata)[s->avctx->extradata_size]);

  687.     }

  688. 

  689.     if (s->context) {

  690.         for (i = 0; i < 3; i++) {

  691.             int pels = s->width * s->height / (i ? 40 : 10);

  692.             for (j = 0; j < 256; j++) {

  693.                 int d = FFMIN(j, 256 - j);

  694.                 s->stats[i][j] = pels/(d + 1);

  695.             }

  696.         }

  697.     } else {

  698.         for (i = 0; i < 3; i++)

  699.             for (j = 0; j < 256; j++)

  700.                 s->stats[i][j]= 0;

  701.     }

  702. 

  703.     alloc_temp(s);

  704. 

  705.     s->picture_number=0;

  706. 

  707.     return 0;

  708. }

  709. #endif /* CONFIG_HUFFYUV_ENCODER || CONFIG_FFVHUFF_ENCODER */

  710. 

  711. /* TODO instead of restarting the read when the code isn't in the first level

  712.  * of the joint table, jump into the 2nd level of the individual table. */

  713. #define READ_2PIX(dst0, dst1, plane1){\

  714.     uint16_t code = get_vlc2(&s->gb, s->vlc[3+plane1].table, VLC_BITS, 1);\

  715.     if(code != 0xffff){\

  716.         dst0 = code>>8;\

  717.         dst1 = code;\

  718.     }else{\

  719.         dst0 = get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3);\

  720.         dst1 = get_vlc2(&s->gb, s->vlc[plane1].table, VLC_BITS, 3);\

  721.     }\

  722. }

  723. 

  724. static void decode_422_bitstream(HYuvContext *s, int count)

  725. {

  726.     int i;

  727. 

  728.     count /= 2;

  729. 

  730.     if (count >= (get_bits_left(&s->gb)) / (31 * 4)) {

  731.         for (i = 0; i < count && get_bits_left(&s->gb) > 0; i++) {

  732.             READ_2PIX(s->temp[0][2 * i    ], s->temp[1][i], 1);

  733.             READ_2PIX(s->temp[0][2 * i + 1], s->temp[2][i], 2);

  734.         }

  735.     } else {

  736.         for (i = 0; i < count; i++) {

  737.             READ_2PIX(s->temp[0][2 * i    ], s->temp[1][i], 1);

  738.             READ_2PIX(s->temp[0][2 * i + 1], s->temp[2][i], 2);

  739.         }

  740.     }

  741. }

  742. 

  743. static void decode_gray_bitstream(HYuvContext *s, int count)

  744. {

  745.     int i;

  746. 

  747.     count/=2;

  748. 

  749.     if (count >= (get_bits_left(&s->gb)) / (31 * 2)) {

  750.         for (i = 0; i < count && get_bits_left(&s->gb) > 0; i++) {

  751.             READ_2PIX(s->temp[0][2 * i], s->temp[0][2 * i + 1], 0);

  752.         }

  753.     } else {

  754.         for(i=0; i<count; i++){

  755.             READ_2PIX(s->temp[0][2 * i], s->temp[0][2 * i + 1], 0);

  756.         }

  757.     }

  758. }

  759. 

  760. #if CONFIG_HUFFYUV_ENCODER || CONFIG_FFVHUFF_ENCODER

  761. static int encode_422_bitstream(HYuvContext *s, int offset, int count)

  762. {

  763.     int i;

  764.     const uint8_t *y = s->temp[0] + offset;

  765.     const uint8_t *u = s->temp[1] + offset / 2;

  766.     const uint8_t *v = s->temp[2] + offset / 2;

  767. 

  768.     if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb) >> 3) < 2 * 4 * count) {

  769.         av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");

  770.         return -1;

  771.     }

  772. 

  773. #define LOAD4\

  774.             int y0 = y[2 * i];\

  775.             int y1 = y[2 * i + 1];\

  776.             int u0 = u[i];\

  777.             int v0 = v[i];

  778. 

  779.     count /= 2;

  780. 

  781.     if (s->flags & CODEC_FLAG_PASS1) {

  782.         for(i = 0; i < count; i++) {

  783.             LOAD4;

  784.             s->stats[0][y0]++;

  785.             s->stats[1][u0]++;

  786.             s->stats[0][y1]++;

  787.             s->stats[2][v0]++;

  788.         }

  789.     }

  790.     if (s->avctx->flags2 & CODEC_FLAG2_NO_OUTPUT)

  791.         return 0;

  792.     if (s->context) {

  793.         for (i = 0; i < count; i++) {

  794.             LOAD4;

  795.             s->stats[0][y0]++;

  796.             put_bits(&s->pb, s->len[0][y0], s->bits[0][y0]);

  797.             s->stats[1][u0]++;

  798.             put_bits(&s->pb, s->len[1][u0], s->bits[1][u0]);

  799.             s->stats[0][y1]++;

  800.             put_bits(&s->pb, s->len[0][y1], s->bits[0][y1]);

  801.             s->stats[2][v0]++;

  802.             put_bits(&s->pb, s->len[2][v0], s->bits[2][v0]);

  803.         }

  804.     } else {

  805.         for(i = 0; i < count; i++) {

  806.             LOAD4;

  807.             put_bits(&s->pb, s->len[0][y0], s->bits[0][y0]);

  808.             put_bits(&s->pb, s->len[1][u0], s->bits[1][u0]);

  809.             put_bits(&s->pb, s->len[0][y1], s->bits[0][y1]);

  810.             put_bits(&s->pb, s->len[2][v0], s->bits[2][v0]);

  811.         }

  812.     }

  813.     return 0;

  814. }

  815. 

  816. static int encode_gray_bitstream(HYuvContext *s, int count)

  817. {

  818.     int i;

  819. 

  820.     if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb) >> 3) < 4 * count) {

  821.         av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");

  822.         return -1;

  823.     }

  824. 

  825. #define LOAD2\

  826.             int y0 = s->temp[0][2 * i];\

  827.             int y1 = s->temp[0][2 * i + 1];

  828. #define STAT2\

  829.             s->stats[0][y0]++;\

  830.             s->stats[0][y1]++;

  831. #define WRITE2\

  832.             put_bits(&s->pb, s->len[0][y0], s->bits[0][y0]);\

  833.             put_bits(&s->pb, s->len[0][y1], s->bits[0][y1]);

  834. 

  835.     count /= 2;

  836. 

  837.     if (s->flags & CODEC_FLAG_PASS1) {

  838.         for (i = 0; i < count; i++) {

  839.             LOAD2;

  840.             STAT2;

  841.         }

  842.     }

  843.     if (s->avctx->flags2 & CODEC_FLAG2_NO_OUTPUT)

  844.         return 0;

  845. 

  846.     if (s->context) {

  847.         for (i = 0; i < count; i++) {

  848.             LOAD2;

  849.             STAT2;

  850.             WRITE2;

  851.         }

  852.     } else {

  853.         for (i = 0; i < count; i++) {

  854.             LOAD2;

  855.             WRITE2;

  856.         }

  857.     }

  858.     return 0;

  859. }

  860. #endif /* CONFIG_HUFFYUV_ENCODER || CONFIG_FFVHUFF_ENCODER */

  861. 

  862. static av_always_inline void decode_bgr_1(HYuvContext *s, int count,

  863.                                           int decorrelate, int alpha)

  864. {

  865.     int i;

  866.     for (i = 0; i < count; i++) {

  867.         int code = get_vlc2(&s->gb, s->vlc[3].table, VLC_BITS, 1);

  868.         if (code != -1) {

  869.             *(uint32_t*)&s->temp[0][4 * i] = s->pix_bgr_map[code];

  870.         } else if(decorrelate) {

  871.             s->temp[0][4 * i + G] = get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3);

  872.             s->temp[0][4 * i + B] = get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3) +

  873.                                     s->temp[0][4 * i + G];

  874.             s->temp[0][4 * i + R] = get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3) +

  875.                                     s->temp[0][4 * i + G];

  876.         } else {

  877.             s->temp[0][4 * i + B] = get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3);

  878.             s->temp[0][4 * i + G] = get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3);

  879.             s->temp[0][4 * i + R] = get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3);

  880.         }

  881.         if (alpha)

  882.             s->temp[0][4 * i + A] = get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3);

  883.     }

  884. }

  885. 

  886. static void decode_bgr_bitstream(HYuvContext *s, int count)

  887. {

  888.     if (s->decorrelate) {

  889.         if (s->bitstream_bpp==24)

  890.             decode_bgr_1(s, count, 1, 0);

  891.         else

  892.             decode_bgr_1(s, count, 1, 1);

  893.     } else {

  894.         if (s->bitstream_bpp==24)

  895.             decode_bgr_1(s, count, 0, 0);

  896.         else

  897.             decode_bgr_1(s, count, 0, 1);

  898.     }

  899. }

  900. 

  901. static inline int encode_bgra_bitstream(HYuvContext *s, int count, int planes)

  902. {

  903.     int i;

  904. 

  905.     if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < 4*planes*count) {

  906.         av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");

  907.         return -1;

  908.     }

  909. 

  910. #define LOAD3\

  911.             int g =  s->temp[0][planes==3 ? 3*i + 1 : 4*i + G];\

  912.             int b = (s->temp[0][planes==3 ? 3*i + 2 : 4*i + B] - g) & 0xff;\

  913.             int r = (s->temp[0][planes==3 ? 3*i + 0 : 4*i + R] - g) & 0xff;\

  914.             int a =  s->temp[0][planes*i + A];

  915. #define STAT3\

  916.             s->stats[0][b]++;\

  917.             s->stats[1][g]++;\

  918.             s->stats[2][r]++;\

  919.             if(planes==4) s->stats[2][a]++;

  920. #define WRITE3\

  921.             put_bits(&s->pb, s->len[1][g], s->bits[1][g]);\

  922.             put_bits(&s->pb, s->len[0][b], s->bits[0][b]);\

  923.             put_bits(&s->pb, s->len[2][r], s->bits[2][r]);\

  924.             if(planes==4) put_bits(&s->pb, s->len[2][a], s->bits[2][a]);

  925. 

  926.     if ((s->flags & CODEC_FLAG_PASS1) &&

  927.         (s->avctx->flags2 & CODEC_FLAG2_NO_OUTPUT)) {

  928.         for (i = 0; i < count; i++) {

  929.             LOAD3;

  930.             STAT3;

  931.         }

  932.     } else if (s->context || (s->flags & CODEC_FLAG_PASS1)) {

  933.         for (i = 0; i < count; i++) {

  934.             LOAD3;

  935.             STAT3;

  936.             WRITE3;

  937.         }

  938.     } else {

  939.         for (i = 0; i < count; i++) {

  940.             LOAD3;

  941.             WRITE3;

  942.         }

  943.     }

  944.     return 0;

  945. }

  946. 

  947. #if CONFIG_HUFFYUV_DECODER || CONFIG_FFVHUFF_DECODER

  948. static void draw_slice(HYuvContext *s, int y)

  949. {

  950.     int h, cy, i;

  951.     int offset[AV_NUM_DATA_POINTERS];

  952. 

  953.     if (s->avctx->draw_horiz_band==NULL)

  954.         return;

  955. 

  956.     h = y - s->last_slice_end;

  957.     y -= h;

  958. 

  959.     if (s->bitstream_bpp == 12) {

  960.         cy = y>>1;

  961.     } else {

  962.         cy = y;

  963.     }

  964. 

  965.     offset[0] = s->picture.linesize[0]*y;

  966.     offset[1] = s->picture.linesize[1]*cy;

  967.     offset[2] = s->picture.linesize[2]*cy;

  968.     for (i = 3; i < AV_NUM_DATA_POINTERS; i++)

  969.         offset[i] = 0;

  970.     emms_c();

  971. 

  972.     s->avctx->draw_horiz_band(s->avctx, &s->picture, offset, y, 3, h);

  973. 

  974.     s->last_slice_end = y + h;

  975. }

  976. 

  977. static int decode_frame(AVCodecContext *avctx, void *data, int *data_size,

  978.                         AVPacket *avpkt)

  979. {

  980.     const uint8_t *buf = avpkt->data;

  981.     int buf_size = avpkt->size;

  982.     HYuvContext *s = avctx->priv_data;

  983.     const int width = s->width;

  984.     const int width2 = s->width>>1;

  985.     const int height = s->height;

  986.     int fake_ystride, fake_ustride, fake_vstride;

  987.     AVFrame * const p = &s->picture;

  988.     int table_size = 0;

  989. 

  990.     AVFrame *picture = data;

  991. 

  992.     av_fast_malloc(&s->bitstream_buffer,

  993.                    &s->bitstream_buffer_size,

  994.                    buf_size + FF_INPUT_BUFFER_PADDING_SIZE);

  995.     if (!s->bitstream_buffer)

  996.         return AVERROR(ENOMEM);

  997. 

  998.     memset(s->bitstream_buffer + buf_size, 0, FF_INPUT_BUFFER_PADDING_SIZE);

  999.     s->dsp.bswap_buf((uint32_t*)s->bitstream_buffer,

  1000.                      (const uint32_t*)buf, buf_size / 4);

  1001. 

  1002.     if (p->data[0])

  1003.         ff_thread_release_buffer(avctx, p);

  1004. 

  1005.     p->reference = 0;

  1006.     if (ff_thread_get_buffer(avctx, p) < 0) {

  1007.         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");

  1008.         return -1;

  1009.     }

  1010. 

  1011.     if (s->context) {

  1012.         table_size = read_huffman_tables(s, s->bitstream_buffer, buf_size);

  1013.         if (table_size < 0)

  1014.             return -1;

  1015.     }

  1016. 

  1017.     if ((unsigned)(buf_size-table_size) >= INT_MAX / 8)

  1018.         return -1;

  1019. 

  1020.     init_get_bits(&s->gb, s->bitstream_buffer+table_size,

  1021.                   (buf_size-table_size) * 8);

  1022. 

  1023.     fake_ystride = s->interlaced ? p->linesize[0] * 2  : p->linesize[0];

  1024.     fake_ustride = s->interlaced ? p->linesize[1] * 2  : p->linesize[1];

  1025.     fake_vstride = s->interlaced ? p->linesize[2] * 2  : p->linesize[2];

  1026. 

  1027.     s->last_slice_end = 0;

  1028. 

  1029.     if (s->bitstream_bpp < 24) {

  1030.         int y, cy;

  1031.         int lefty, leftu, leftv;

  1032.         int lefttopy, lefttopu, lefttopv;

  1033. 

  1034.         if (s->yuy2) {

  1035.             p->data[0][3] = get_bits(&s->gb, 8);

  1036.             p->data[0][2] = get_bits(&s->gb, 8);

  1037.             p->data[0][1] = get_bits(&s->gb, 8);

  1038.             p->data[0][0] = get_bits(&s->gb, 8);

  1039. 

  1040.             av_log(avctx, AV_LOG_ERROR,

  1041.                    "YUY2 output is not implemented yet\n");

  1042.             return -1;

  1043.         } else {

  1044. 

  1045.             leftv = p->data[2][0] = get_bits(&s->gb, 8);

  1046.             lefty = p->data[0][1] = get_bits(&s->gb, 8);

  1047.             leftu = p->data[1][0] = get_bits(&s->gb, 8);

  1048.                     p->data[0][0] = get_bits(&s->gb, 8);

  1049. 

  1050.             switch (s->predictor) {

  1051.             case LEFT:

  1052.             case PLANE:

  1053.                 decode_422_bitstream(s, width-2);

  1054.                 lefty = s->dsp.add_hfyu_left_prediction(p->data[0] + 2, s->temp[0], width-2, lefty);

  1055.                 if (!(s->flags&CODEC_FLAG_GRAY)) {

  1056.                     leftu = s->dsp.add_hfyu_left_prediction(p->data[1] + 1, s->temp[1], width2 - 1, leftu);

  1057.                     leftv = s->dsp.add_hfyu_left_prediction(p->data[2] + 1, s->temp[2], width2 - 1, leftv);

  1058.                 }

  1059. 

  1060.                 for (cy = y = 1; y < s->height; y++, cy++) {

  1061.                     uint8_t *ydst, *udst, *vdst;

  1062. 

  1063.                     if (s->bitstream_bpp == 12) {

  1064.                         decode_gray_bitstream(s, width);

  1065. 

  1066.                         ydst = p->data[0] + p->linesize[0] * y;

  1067. 

  1068.                         lefty = s->dsp.add_hfyu_left_prediction(ydst, s->temp[0], width, lefty);

  1069.                         if (s->predictor == PLANE) {

  1070.                             if (y > s->interlaced)

  1071.                                 s->dsp.add_bytes(ydst, ydst - fake_ystride, width);

  1072.                         }

  1073.                         y++;

  1074.                         if (y >= s->height) break;

  1075.                     }

  1076. 

  1077.                     draw_slice(s, y);

  1078. 

  1079.                     ydst = p->data[0] + p->linesize[0]*y;

  1080.                     udst = p->data[1] + p->linesize[1]*cy;

  1081.                     vdst = p->data[2] + p->linesize[2]*cy;

  1082. 

  1083.                     decode_422_bitstream(s, width);

  1084.                     lefty = s->dsp.add_hfyu_left_prediction(ydst, s->temp[0], width, lefty);

  1085.                     if (!(s->flags & CODEC_FLAG_GRAY)) {

  1086.                         leftu= s->dsp.add_hfyu_left_prediction(udst, s->temp[1], width2, leftu);

  1087.                         leftv= s->dsp.add_hfyu_left_prediction(vdst, s->temp[2], width2, leftv);

  1088.                     }

  1089.                     if (s->predictor == PLANE) {

  1090.                         if (cy > s->interlaced) {

  1091.                             s->dsp.add_bytes(ydst, ydst - fake_ystride, width);

  1092.                             if (!(s->flags & CODEC_FLAG_GRAY)) {

  1093.                                 s->dsp.add_bytes(udst, udst - fake_ustride, width2);

  1094.                                 s->dsp.add_bytes(vdst, vdst - fake_vstride, width2);

  1095.                             }

  1096.                         }

  1097.                     }

  1098.                 }

  1099.                 draw_slice(s, height);

  1100. 

  1101.                 break;

  1102.             case MEDIAN:

  1103.                 /* first line except first 2 pixels is left predicted */

  1104.                 decode_422_bitstream(s, width - 2);

  1105.                 lefty= s->dsp.add_hfyu_left_prediction(p->data[0] + 2, s->temp[0], width - 2, lefty);

  1106.                 if (!(s->flags & CODEC_FLAG_GRAY)) {

  1107.                     leftu = s->dsp.add_hfyu_left_prediction(p->data[1] + 1, s->temp[1], width2 - 1, leftu);

  1108.                     leftv = s->dsp.add_hfyu_left_prediction(p->data[2] + 1, s->temp[2], width2 - 1, leftv);

  1109.                 }

  1110. 

  1111.                 cy = y = 1;

  1112. 

  1113.                 /* second line is left predicted for interlaced case */

  1114.                 if (s->interlaced) {

  1115.                     decode_422_bitstream(s, width);

  1116.                     lefty = s->dsp.add_hfyu_left_prediction(p->data[0] + p->linesize[0], s->temp[0], width, lefty);

  1117.                     if (!(s->flags & CODEC_FLAG_GRAY)) {

  1118.                         leftu = s->dsp.add_hfyu_left_prediction(p->data[1] + p->linesize[2], s->temp[1], width2, leftu);

  1119.                         leftv = s->dsp.add_hfyu_left_prediction(p->data[2] + p->linesize[1], s->temp[2], width2, leftv);

  1120.                     }

  1121.                     y++; cy++;

  1122.                 }

  1123. 

  1124.                 /* next 4 pixels are left predicted too */

  1125.                 decode_422_bitstream(s, 4);

  1126.                 lefty = s->dsp.add_hfyu_left_prediction(p->data[0] + fake_ystride, s->temp[0], 4, lefty);

  1127.                 if (!(s->flags&CODEC_FLAG_GRAY)) {

  1128.                     leftu = s->dsp.add_hfyu_left_prediction(p->data[1] + fake_ustride, s->temp[1], 2, leftu);

  1129.                     leftv = s->dsp.add_hfyu_left_prediction(p->data[2] + fake_vstride, s->temp[2], 2, leftv);

  1130.                 }

  1131. 

  1132.                 /* next line except the first 4 pixels is median predicted */

  1133.                 lefttopy = p->data[0][3];

  1134.                 decode_422_bitstream(s, width - 4);

  1135.                 s->dsp.add_hfyu_median_prediction(p->data[0] + fake_ystride+4, p->data[0]+4, s->temp[0], width-4, &lefty, &lefttopy);

  1136.                 if (!(s->flags&CODEC_FLAG_GRAY)) {

  1137.                     lefttopu = p->data[1][1];

  1138.                     lefttopv = p->data[2][1];

  1139.                     s->dsp.add_hfyu_median_prediction(p->data[1] + fake_ustride+2, p->data[1] + 2, s->temp[1], width2 - 2, &leftu, &lefttopu);

  1140.                     s->dsp.add_hfyu_median_prediction(p->data[2] + fake_vstride+2, p->data[2] + 2, s->temp[2], width2 - 2, &leftv, &lefttopv);

  1141.                 }

  1142.                 y++; cy++;

  1143. 

  1144.                 for (; y<height; y++, cy++) {

  1145.                     uint8_t *ydst, *udst, *vdst;

  1146. 

  1147.                     if (s->bitstream_bpp == 12) {

  1148.                         while (2 * cy > y) {

  1149.                             decode_gray_bitstream(s, width);

  1150.                             ydst = p->data[0] + p->linesize[0] * y;

  1151.                             s->dsp.add_hfyu_median_prediction(ydst, ydst - fake_ystride, s->temp[0], width, &lefty, &lefttopy);

  1152.                             y++;

  1153.                         }

  1154.                         if (y >= height) break;

  1155.                     }

  1156.                     draw_slice(s, y);

  1157. 

  1158.                     decode_422_bitstream(s, width);

  1159. 

  1160.                     ydst = p->data[0] + p->linesize[0] * y;

  1161.                     udst = p->data[1] + p->linesize[1] * cy;

  1162.                     vdst = p->data[2] + p->linesize[2] * cy;

  1163. 

  1164.                     s->dsp.add_hfyu_median_prediction(ydst, ydst - fake_ystride, s->temp[0], width, &lefty, &lefttopy);

  1165.                     if (!(s->flags & CODEC_FLAG_GRAY)) {

  1166.                         s->dsp.add_hfyu_median_prediction(udst, udst - fake_ustride, s->temp[1], width2, &leftu, &lefttopu);

  1167.                         s->dsp.add_hfyu_median_prediction(vdst, vdst - fake_vstride, s->temp[2], width2, &leftv, &lefttopv);

  1168.                     }

  1169.                 }

  1170. 

  1171.                 draw_slice(s, height);

  1172.                 break;

  1173.             }

  1174.         }

  1175.     } else {

  1176.         int y;

  1177.         int leftr, leftg, leftb, lefta;

  1178.         const int last_line = (height - 1) * p->linesize[0];

  1179. 

  1180.         if (s->bitstream_bpp == 32) {

  1181.             lefta = p->data[0][last_line+A] = get_bits(&s->gb, 8);

  1182.             leftr = p->data[0][last_line+R] = get_bits(&s->gb, 8);

  1183.             leftg = p->data[0][last_line+G] = get_bits(&s->gb, 8);

  1184.             leftb = p->data[0][last_line+B] = get_bits(&s->gb, 8);

  1185.         } else {

  1186.             leftr = p->data[0][last_line+R] = get_bits(&s->gb, 8);

  1187.             leftg = p->data[0][last_line+G] = get_bits(&s->gb, 8);

  1188.             leftb = p->data[0][last_line+B] = get_bits(&s->gb, 8);

  1189.             lefta = p->data[0][last_line+A] = 255;

  1190.             skip_bits(&s->gb, 8);

  1191.         }

  1192. 

  1193.         if (s->bgr32) {

  1194.             switch (s->predictor) {

  1195.             case LEFT:

  1196.             case PLANE:

  1197.                 decode_bgr_bitstream(s, width - 1);

  1198.                 s->dsp.add_hfyu_left_prediction_bgr32(p->data[0] + last_line+4, s->temp[0], width - 1, &leftr, &leftg, &leftb, &lefta);

  1199. 

  1200.                 for (y = s->height - 2; y >= 0; y--) { //Yes it is stored upside down.

  1201.                     decode_bgr_bitstream(s, width);

  1202. 

  1203.                     s->dsp.add_hfyu_left_prediction_bgr32(p->data[0] + p->linesize[0]*y, s->temp[0], width, &leftr, &leftg, &leftb, &lefta);

  1204.                     if (s->predictor == PLANE) {

  1205.                         if (s->bitstream_bpp != 32) lefta = 0;

  1206.                         if ((y & s->interlaced) == 0 &&

  1207.                             y < s->height - 1 - s->interlaced) {

  1208.                             s->dsp.add_bytes(p->data[0] + p->linesize[0] * y,

  1209.                                              p->data[0] + p->linesize[0] * y +

  1210.                                              fake_ystride, fake_ystride);

  1211.                         }

  1212.                     }

  1213.                 }

  1214.                 // just 1 large slice as this is not possible in reverse order

  1215.                 draw_slice(s, height);

  1216.                 break;

  1217.             default:

  1218.                 av_log(avctx, AV_LOG_ERROR,

  1219.                        "prediction type not supported!\n");

  1220.             }

  1221.         }else{

  1222.             av_log(avctx, AV_LOG_ERROR,

  1223.                    "BGR24 output is not implemented yet\n");

  1224.             return -1;

  1225.         }

  1226.     }

  1227.     emms_c();

  1228. 

  1229.     *picture = *p;

  1230.     *data_size = sizeof(AVFrame);

  1231. 

  1232.     return (get_bits_count(&s->gb) + 31) / 32 * 4 + table_size;

  1233. }

  1234. #endif /* CONFIG_HUFFYUV_DECODER || CONFIG_FFVHUFF_DECODER */

  1235. 

  1236. static int common_end(HYuvContext *s)

  1237. {

  1238.     int i;

  1239. 

  1240.     for(i = 0; i < 3; i++) {

  1241.         av_freep(&s->temp[i]);

  1242.     }

  1243.     return 0;

  1244. }

  1245. 

  1246. #if CONFIG_HUFFYUV_DECODER || CONFIG_FFVHUFF_DECODER

  1247. static av_cold int decode_end(AVCodecContext *avctx)

  1248. {

  1249.     HYuvContext *s = avctx->priv_data;

  1250.     int i;

  1251. 

  1252.     if (s->picture.data[0])

  1253.         avctx->release_buffer(avctx, &s->picture);

  1254. 

  1255.     common_end(s);

  1256.     av_freep(&s->bitstream_buffer);

  1257. 

  1258.     for (i = 0; i < 6; i++) {

  1259.         ff_free_vlc(&s->vlc[i]);

  1260.     }

  1261. 

  1262.     return 0;

  1263. }

  1264. #endif /* CONFIG_HUFFYUV_DECODER || CONFIG_FFVHUFF_DECODER */

  1265. 

  1266. #if CONFIG_HUFFYUV_ENCODER || CONFIG_FFVHUFF_ENCODER

  1267. static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,

  1268.                         const AVFrame *pict, int *got_packet)

  1269. {

  1270.     HYuvContext *s = avctx->priv_data;

  1271.     const int width = s->width;

  1272.     const int width2 = s->width>>1;

  1273.     const int height = s->height;

  1274.     const int fake_ystride = s->interlaced ? pict->linesize[0]*2  : pict->linesize[0];

  1275.     const int fake_ustride = s->interlaced ? pict->linesize[1]*2  : pict->linesize[1];

  1276.     const int fake_vstride = s->interlaced ? pict->linesize[2]*2  : pict->linesize[2];

  1277.     AVFrame * const p = &s->picture;

  1278.     int i, j, size = 0, ret;

  1279. 

  1280.     if ((ret = ff_alloc_packet2(avctx, pkt, width * height * 3 * 4 + FF_MIN_BUFFER_SIZE)) < 0)

  1281.         return ret;

  1282. 

  1283.     *p = *pict;

  1284.     p->pict_type = AV_PICTURE_TYPE_I;

  1285.     p->key_frame = 1;

  1286. 

  1287.     if (s->context) {

  1288.         for (i = 0; i < 3; i++) {

  1289.             ff_huff_gen_len_table(s->len[i], s->stats[i]);

  1290.             if (generate_bits_table(s->bits[i], s->len[i]) < 0)

  1291.                 return -1;

  1292.             size += store_table(s, s->len[i], &pkt->data[size]);

  1293.         }

  1294. 

  1295.         for (i = 0; i < 3; i++)

  1296.             for (j = 0; j < 256; j++)

  1297.                 s->stats[i][j] >>= 1;

  1298.     }

  1299. 

  1300.     init_put_bits(&s->pb, pkt->data + size, pkt->size - size);

  1301. 

  1302.     if (avctx->pix_fmt == AV_PIX_FMT_YUV422P ||

  1303.         avctx->pix_fmt == AV_PIX_FMT_YUV420P) {

  1304.         int lefty, leftu, leftv, y, cy;

  1305. 

  1306.         put_bits(&s->pb, 8, leftv = p->data[2][0]);

  1307.         put_bits(&s->pb, 8, lefty = p->data[0][1]);

  1308.         put_bits(&s->pb, 8, leftu = p->data[1][0]);

  1309.         put_bits(&s->pb, 8,         p->data[0][0]);

  1310. 

  1311.         lefty = sub_left_prediction(s, s->temp[0], p->data[0], width , 0);

  1312.         leftu = sub_left_prediction(s, s->temp[1], p->data[1], width2, 0);

  1313.         leftv = sub_left_prediction(s, s->temp[2], p->data[2], width2, 0);

  1314. 

  1315.         encode_422_bitstream(s, 2, width-2);

  1316. 

  1317.         if (s->predictor==MEDIAN) {

  1318.             int lefttopy, lefttopu, lefttopv;

  1319.             cy = y = 1;

  1320.             if (s->interlaced) {

  1321.                 lefty = sub_left_prediction(s, s->temp[0], p->data[0] + p->linesize[0], width , lefty);

  1322.                 leftu = sub_left_prediction(s, s->temp[1], p->data[1] + p->linesize[1], width2, leftu);

  1323.                 leftv = sub_left_prediction(s, s->temp[2], p->data[2] + p->linesize[2], width2, leftv);

  1324. 

  1325.                 encode_422_bitstream(s, 0, width);

  1326.                 y++; cy++;

  1327.             }

  1328. 

  1329.             lefty = sub_left_prediction(s, s->temp[0], p->data[0] + fake_ystride, 4, lefty);

  1330.             leftu = sub_left_prediction(s, s->temp[1], p->data[1] + fake_ustride, 2, leftu);

  1331.             leftv = sub_left_prediction(s, s->temp[2], p->data[2] + fake_vstride, 2, leftv);

  1332. 

  1333.             encode_422_bitstream(s, 0, 4);

  1334. 

  1335.             lefttopy = p->data[0][3];

  1336.             lefttopu = p->data[1][1];

  1337.             lefttopv = p->data[2][1];

  1338.             s->dsp.sub_hfyu_median_prediction(s->temp[0], p->data[0]+4, p->data[0] + fake_ystride + 4, width - 4 , &lefty, &lefttopy);

  1339.             s->dsp.sub_hfyu_median_prediction(s->temp[1], p->data[1]+2, p->data[1] + fake_ustride + 2, width2 - 2, &leftu, &lefttopu);

  1340.             s->dsp.sub_hfyu_median_prediction(s->temp[2], p->data[2]+2, p->data[2] + fake_vstride + 2, width2 - 2, &leftv, &lefttopv);

  1341.             encode_422_bitstream(s, 0, width - 4);

  1342.             y++; cy++;

  1343. 

  1344.             for (; y < height; y++,cy++) {

  1345.                 uint8_t *ydst, *udst, *vdst;

  1346. 

  1347.                 if (s->bitstream_bpp == 12) {

  1348.                     while (2 * cy > y) {

  1349.                         ydst = p->data[0] + p->linesize[0] * y;

  1350.                         s->dsp.sub_hfyu_median_prediction(s->temp[0], ydst - fake_ystride, ydst, width , &lefty, &lefttopy);

  1351.                         encode_gray_bitstream(s, width);

  1352.                         y++;

  1353.                     }

  1354.                     if (y >= height) break;

  1355.                 }

  1356.                 ydst = p->data[0] + p->linesize[0] * y;

  1357.                 udst = p->data[1] + p->linesize[1] * cy;

  1358.                 vdst = p->data[2] + p->linesize[2] * cy;

  1359. 

  1360.                 s->dsp.sub_hfyu_median_prediction(s->temp[0], ydst - fake_ystride, ydst, width , &lefty, &lefttopy);

  1361.                 s->dsp.sub_hfyu_median_prediction(s->temp[1], udst - fake_ustride, udst, width2, &leftu, &lefttopu);

  1362.                 s->dsp.sub_hfyu_median_prediction(s->temp[2], vdst - fake_vstride, vdst, width2, &leftv, &lefttopv);

  1363. 

  1364.                 encode_422_bitstream(s, 0, width);

  1365.             }

  1366.         } else {

  1367.             for (cy = y = 1; y < height; y++, cy++) {

  1368.                 uint8_t *ydst, *udst, *vdst;

  1369. 

  1370.                 /* encode a luma only line & y++ */

  1371.                 if (s->bitstream_bpp == 12) {

  1372.                     ydst = p->data[0] + p->linesize[0] * y;

  1373. 

  1374.                     if (s->predictor == PLANE && s->interlaced < y) {

  1375.                         s->dsp.diff_bytes(s->temp[1], ydst, ydst - fake_ystride, width);

  1376. 

  1377.                         lefty = sub_left_prediction(s, s->temp[0], s->temp[1], width , lefty);

  1378.                     } else {

  1379.                         lefty = sub_left_prediction(s, s->temp[0], ydst, width , lefty);

  1380.                     }

  1381.                     encode_gray_bitstream(s, width);

  1382.                     y++;

  1383.                     if (y >= height) break;

  1384.                 }

  1385. 

  1386.                 ydst = p->data[0] + p->linesize[0] * y;

  1387.                 udst = p->data[1] + p->linesize[1] * cy;

  1388.                 vdst = p->data[2] + p->linesize[2] * cy;

  1389. 

  1390.                 if (s->predictor == PLANE && s->interlaced < cy) {

  1391.                     s->dsp.diff_bytes(s->temp[1], ydst, ydst - fake_ystride, width);

  1392.                     s->dsp.diff_bytes(s->temp[2], udst, udst - fake_ustride, width2);

  1393.                     s->dsp.diff_bytes(s->temp[2] + width2, vdst, vdst - fake_vstride, width2);

  1394. 

  1395.                     lefty = sub_left_prediction(s, s->temp[0], s->temp[1], width , lefty);

  1396.                     leftu = sub_left_prediction(s, s->temp[1], s->temp[2], width2, leftu);

  1397.                     leftv = sub_left_prediction(s, s->temp[2], s->temp[2] + width2, width2, leftv);

  1398.                 } else {

  1399.                     lefty = sub_left_prediction(s, s->temp[0], ydst, width , lefty);

  1400.                     leftu = sub_left_prediction(s, s->temp[1], udst, width2, leftu);

  1401.                     leftv = sub_left_prediction(s, s->temp[2], vdst, width2, leftv);

  1402.                 }

  1403. 

  1404.                 encode_422_bitstream(s, 0, width);

  1405.             }

  1406.         }

  1407.     } else if(avctx->pix_fmt == AV_PIX_FMT_RGB32) {

  1408.         uint8_t *data = p->data[0] + (height - 1) * p->linesize[0];

  1409.         const int stride = -p->linesize[0];

  1410.         const int fake_stride = -fake_ystride;

  1411.         int y;

  1412.         int leftr, leftg, leftb, lefta;

  1413. 

  1414.         put_bits(&s->pb, 8, lefta = data[A]);

  1415.         put_bits(&s->pb, 8, leftr = data[R]);

  1416.         put_bits(&s->pb, 8, leftg = data[G]);

  1417.         put_bits(&s->pb, 8, leftb = data[B]);

  1418. 

  1419.         sub_left_prediction_bgr32(s, s->temp[0], data + 4, width - 1, &leftr, &leftg, &leftb, &lefta);

  1420.         encode_bgra_bitstream(s, width - 1, 4);

  1421. 

  1422.         for (y = 1; y < s->height; y++) {

  1423.             uint8_t *dst = data + y*stride;

  1424.             if (s->predictor == PLANE && s->interlaced < y) {

  1425.                 s->dsp.diff_bytes(s->temp[1], dst, dst - fake_stride, width * 4);

  1426.                 sub_left_prediction_bgr32(s, s->temp[0], s->temp[1], width, &leftr, &leftg, &leftb, &lefta);

  1427.             } else {

  1428.                 sub_left_prediction_bgr32(s, s->temp[0], dst, width, &leftr, &leftg, &leftb, &lefta);

  1429.             }

  1430.             encode_bgra_bitstream(s, width, 4);

  1431.         }

  1432.     }else if(avctx->pix_fmt == AV_PIX_FMT_RGB24){

  1433.         uint8_t *data = p->data[0] + (height-1)*p->linesize[0];

  1434.         const int stride = -p->linesize[0];

  1435.         const int fake_stride = -fake_ystride;

  1436.         int y;

  1437.         int leftr, leftg, leftb;

  1438. 

  1439.         put_bits(&s->pb, 8, leftr= data[0]);

  1440.         put_bits(&s->pb, 8, leftg= data[1]);

  1441.         put_bits(&s->pb, 8, leftb= data[2]);

  1442.         put_bits(&s->pb, 8, 0);

  1443. 

  1444.         sub_left_prediction_rgb24(s, s->temp[0], data+3, width-1, &leftr, &leftg, &leftb);

  1445.         encode_bgra_bitstream(s, width-1, 3);

  1446. 

  1447.         for(y=1; y<s->height; y++){

  1448.             uint8_t *dst = data + y*stride;

  1449.             if(s->predictor == PLANE && s->interlaced < y){

  1450.                 s->dsp.diff_bytes(s->temp[1], dst, dst - fake_stride, width*3);

  1451.                 sub_left_prediction_rgb24(s, s->temp[0], s->temp[1], width, &leftr, &leftg, &leftb);

  1452.             }else{

  1453.                 sub_left_prediction_rgb24(s, s->temp[0], dst, width, &leftr, &leftg, &leftb);

  1454.             }

  1455.             encode_bgra_bitstream(s, width, 3);

  1456.         }

  1457.     } else {

  1458.         av_log(avctx, AV_LOG_ERROR, "Format not supported!\n");

  1459.     }

  1460.     emms_c();

  1461. 

  1462.     size += (put_bits_count(&s->pb) + 31) / 8;

  1463.     put_bits(&s->pb, 16, 0);

  1464.     put_bits(&s->pb, 15, 0);

  1465.     size /= 4;

  1466. 

  1467.     if ((s->flags&CODEC_FLAG_PASS1) && (s->picture_number & 31) == 0) {

  1468.         int j;

  1469.         char *p = avctx->stats_out;

  1470.         char *end = p + 1024*30;

  1471.         for (i = 0; i < 3; i++) {

  1472.             for (j = 0; j < 256; j++) {

  1473.                 snprintf(p, end-p, "%"PRIu64" ", s->stats[i][j]);

  1474.                 p += strlen(p);

  1475.                 s->stats[i][j]= 0;

  1476.             }

  1477.             snprintf(p, end-p, "\n");

  1478.             p++;

  1479.         }

  1480.     } else

  1481.         avctx->stats_out[0] = '\0';

  1482.     if (!(s->avctx->flags2 & CODEC_FLAG2_NO_OUTPUT)) {

  1483.         flush_put_bits(&s->pb);

  1484.         s->dsp.bswap_buf((uint32_t*)pkt->data, (uint32_t*)pkt->data, size);

  1485.     }

  1486. 

  1487.     s->picture_number++;

  1488. 

  1489.     pkt->size   = size * 4;

  1490.     pkt->flags |= AV_PKT_FLAG_KEY;

  1491.     *got_packet = 1;

  1492. 

  1493.     return 0;

  1494. }

  1495. 

  1496. static av_cold int encode_end(AVCodecContext *avctx)

  1497. {

  1498.     HYuvContext *s = avctx->priv_data;

  1499. 

  1500.     common_end(s);

  1501. 

  1502.     av_freep(&avctx->extradata);

  1503.     av_freep(&avctx->stats_out);

  1504. 

  1505.     return 0;

  1506. }

  1507. #endif /* CONFIG_HUFFYUV_ENCODER || CONFIG_FFVHUFF_ENCODER */

  1508. 

  1509. #if CONFIG_HUFFYUV_DECODER

  1510. AVCodec ff_huffyuv_decoder = {

  1511.     .name             = "huffyuv",

  1512.     .type             = AVMEDIA_TYPE_VIDEO,

  1513.     .id               = AV_CODEC_ID_HUFFYUV,

  1514.     .priv_data_size   = sizeof(HYuvContext),

  1515.     .init             = decode_init,

  1516.     .close            = decode_end,

  1517.     .decode           = decode_frame,

  1518.     .capabilities     = CODEC_CAP_DR1 | CODEC_CAP_DRAW_HORIZ_BAND |

  1519.                         CODEC_CAP_FRAME_THREADS,

  1520.     .init_thread_copy = ONLY_IF_THREADS_ENABLED(decode_init_thread_copy),

  1521.     .long_name        = NULL_IF_CONFIG_SMALL("Huffyuv / HuffYUV"),

  1522. };

  1523. #endif

  1524. 

  1525. #if CONFIG_FFVHUFF_DECODER

  1526. AVCodec ff_ffvhuff_decoder = {

  1527.     .name             = "ffvhuff",

  1528.     .type             = AVMEDIA_TYPE_VIDEO,

  1529.     .id               = AV_CODEC_ID_FFVHUFF,

  1530.     .priv_data_size   = sizeof(HYuvContext),

  1531.     .init             = decode_init,

  1532.     .close            = decode_end,

  1533.     .decode           = decode_frame,

  1534.     .capabilities     = CODEC_CAP_DR1 | CODEC_CAP_DRAW_HORIZ_BAND |

  1535.                         CODEC_CAP_FRAME_THREADS,

  1536.     .init_thread_copy = ONLY_IF_THREADS_ENABLED(decode_init_thread_copy),

  1537.     .long_name        = NULL_IF_CONFIG_SMALL("Huffyuv FFmpeg variant"),

  1538. };

  1539. #endif

  1540. 

  1541. #if CONFIG_HUFFYUV_ENCODER

  1542. AVCodec ff_huffyuv_encoder = {

  1543.     .name           = "huffyuv",

  1544.     .type           = AVMEDIA_TYPE_VIDEO,

  1545.     .id             = AV_CODEC_ID_HUFFYUV,

  1546.     .priv_data_size = sizeof(HYuvContext),

  1547.     .init           = encode_init,

  1548.     .encode2        = encode_frame,

  1549.     .close          = encode_end,

  1550.     .pix_fmts       = (const enum AVPixelFormat[]){

  1551.         AV_PIX_FMT_YUV422P, AV_PIX_FMT_RGB24, AV_PIX_FMT_RGB32, AV_PIX_FMT_NONE

  1552.     },

  1553.     .long_name      = NULL_IF_CONFIG_SMALL("Huffyuv / HuffYUV"),

  1554. };

  1555. #endif

  1556. 

  1557. #if CONFIG_FFVHUFF_ENCODER

  1558. AVCodec ff_ffvhuff_encoder = {

  1559.     .name           = "ffvhuff",

  1560.     .type           = AVMEDIA_TYPE_VIDEO,

  1561.     .id             = AV_CODEC_ID_FFVHUFF,

  1562.     .priv_data_size = sizeof(HYuvContext),

  1563.     .init           = encode_init,

  1564.     .encode2        = encode_frame,

  1565.     .close          = encode_end,

  1566.     .pix_fmts       = (const enum AVPixelFormat[]){

  1567.         AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_RGB24, AV_PIX_FMT_RGB32, AV_PIX_FMT_NONE

  1568.     },

  1569.     .long_name      = NULL_IF_CONFIG_SMALL("Huffyuv FFmpeg variant"),

  1570. };

  1571. #endif