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

1575 lines
53KB
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.     if (s->predictor == MEDIAN && avctx->pix_fmt == AV_PIX_FMT_YUV422P && avctx->width%4) {

  518.         av_log(avctx, AV_LOG_ERROR, "width must be a multiple of 4 this colorspace and predictor\n");

  519.         return AVERROR_INVALIDDATA;

  520.     }

  521.     alloc_temp(s);

  522. 

  523.     return 0;

  524. }

  525. 

  526. static av_cold int decode_init_thread_copy(AVCodecContext *avctx)

  527. {

  528.     HYuvContext *s = avctx->priv_data;

  529.     int i;

  530. 

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

  532.     alloc_temp(s);

  533. 

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

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

  536. 

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

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

  539.                                 avctx->extradata_size) < 0)

  540.             return -1;

  541.     } else {

  542.         if (read_old_huffman_tables(s) < 0)

  543.             return -1;

  544.     }

  545. 

  546.     return 0;

  547. }

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

  549. 

  550. #if CONFIG_HUFFYUV_ENCODER || CONFIG_FFVHUFF_ENCODER

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

  552. {

  553.     int i;

  554.     int index = 0;

  555. 

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

  557.         int val = len[i];

  558.         int repeat = 0;

  559. 

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

  561.             repeat++;

  562. 

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

  564.         if (repeat > 7) {

  565.             buf[index++] = val;

  566.             buf[index++] = repeat;

  567.         } else {

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

  569.         }

  570.     }

  571. 

  572.     return index;

  573. }

  574. 

  575. static av_cold int encode_init(AVCodecContext *avctx)

  576. {

  577.     HYuvContext *s = avctx->priv_data;

  578.     int i, j;

  579. 

  580.     common_init(avctx);

  581. 

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

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

  584.     s->version = 2;

  585. 

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

  587. 

  588.     switch (avctx->pix_fmt) {

  589.     case AV_PIX_FMT_YUV420P:

  590.     case AV_PIX_FMT_YUV422P:

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

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

  593.             return AVERROR(EINVAL);

  594.         }

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

  596.         break;

  597.     case AV_PIX_FMT_RGB32:

  598.         s->bitstream_bpp = 32;

  599.         break;

  600.     case AV_PIX_FMT_RGB24:

  601.         s->bitstream_bpp = 24;

  602.         break;

  603.     default:

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

  605.         return -1;

  606.     }

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

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

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

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

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

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

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

  614.             av_log(avctx, AV_LOG_ERROR,

  615.                    "context=1 is not compatible with "

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

  617.             return -1;

  618.         }

  619.     }else s->context= 0;

  620. 

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

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

  623.             av_log(avctx, AV_LOG_ERROR,

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

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

  626.             return -1;

  627.         }

  628.         if (avctx->context_model) {

  629.             av_log(avctx, AV_LOG_ERROR,

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

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

  632.             return -1;

  633.         }

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

  635.             av_log(avctx, AV_LOG_INFO,

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

  637.     }

  638. 

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

  640.         av_log(avctx, AV_LOG_ERROR,

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

  642.         return -1;

  643.     }

  644. 

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

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

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

  648.     if (s->context)

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

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

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

  652. 

  653.     if (avctx->stats_in) {

  654.         char *p = avctx->stats_in;

  655. 

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

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

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

  659. 

  660.         for (;;) {

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

  662.                 char *next;

  663. 

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

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

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

  667.                     p = next;

  668.                 }

  669.             }

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

  671.         }

  672.     } else {

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

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

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

  676. 

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

  678.             }

  679.     }

  680. 

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

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

  683. 

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

  685.             return -1;

  686.         }

  687. 

  688.         s->avctx->extradata_size +=

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

  690.     }

  691. 

  692.     if (s->context) {

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

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

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

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

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

  698.             }

  699.         }

  700.     } else {

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

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

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

  704.     }

  705. 

  706.     alloc_temp(s);

  707. 

  708.     s->picture_number=0;

  709. 

  710.     return 0;

  711. }

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

  713. 

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

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

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

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

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

  719.         dst0 = code>>8;\

  720.         dst1 = code;\

  721.     }else{\

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

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

  724.     }\

  725. }

  726. 

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

  728. {

  729.     int i;

  730. 

  731.     count /= 2;

  732. 

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

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

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

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

  737.         }

  738.     } else {

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

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

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

  742.         }

  743.     }

  744. }

  745. 

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

  747. {

  748.     int i;

  749. 

  750.     count/=2;

  751. 

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

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

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

  755.         }

  756.     } else {

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

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

  759.         }

  760.     }

  761. }

  762. 

  763. #if CONFIG_HUFFYUV_ENCODER || CONFIG_FFVHUFF_ENCODER

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

  765. {

  766.     int i;

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

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

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

  770. 

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

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

  773.         return -1;

  774.     }

  775. 

  776. #define LOAD4\

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

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

  779.             int u0 = u[i];\

  780.             int v0 = v[i];

  781. 

  782.     count /= 2;

  783. 

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

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

  786.             LOAD4;

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

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

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

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

  791.         }

  792.     }

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

  794.         return 0;

  795.     if (s->context) {

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

  797.             LOAD4;

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

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

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

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

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

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

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

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

  806.         }

  807.     } else {

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

  809.             LOAD4;

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

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

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

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

  814.         }

  815.     }

  816.     return 0;

  817. }

  818. 

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

  820. {

  821.     int i;

  822. 

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

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

  825.         return -1;

  826.     }

  827. 

  828. #define LOAD2\

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

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

  831. #define STAT2\

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

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

  834. #define WRITE2\

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

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

  837. 

  838.     count /= 2;

  839. 

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

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

  842.             LOAD2;

  843.             STAT2;

  844.         }

  845.     }

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

  847.         return 0;

  848. 

  849.     if (s->context) {

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

  851.             LOAD2;

  852.             STAT2;

  853.             WRITE2;

  854.         }

  855.     } else {

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

  857.             LOAD2;

  858.             WRITE2;

  859.         }

  860.     }

  861.     return 0;

  862. }

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

  864. 

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

  866.                                           int decorrelate, int alpha)

  867. {

  868.     int i;

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

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

  871.         if (code != -1) {

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

  873.         } else if(decorrelate) {

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

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

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

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

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

  879.         } else {

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

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

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

  883.         }

  884.         if (alpha)

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

  886.     }

  887. }

  888. 

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

  890. {

  891.     if (s->decorrelate) {

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

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

  894.         else

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

  896.     } else {

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

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

  899.         else

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

  901.     }

  902. }

  903. 

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

  905. {

  906.     int i;

  907. 

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

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

  910.         return -1;

  911.     }

  912. 

  913. #define LOAD3\

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

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

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

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

  918. #define STAT3\

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

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

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

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

  923. #define WRITE3\

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

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

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

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

  928. 

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

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

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

  932.             LOAD3;

  933.             STAT3;

  934.         }

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

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

  937.             LOAD3;

  938.             STAT3;

  939.             WRITE3;

  940.         }

  941.     } else {

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

  943.             LOAD3;

  944.             WRITE3;

  945.         }

  946.     }

  947.     return 0;

  948. }

  949. 

  950. #if CONFIG_HUFFYUV_DECODER || CONFIG_FFVHUFF_DECODER

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

  952. {

  953.     int h, cy, i;

  954.     int offset[AV_NUM_DATA_POINTERS];

  955. 

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

  957.         return;

  958. 

  959.     h = y - s->last_slice_end;

  960.     y -= h;

  961. 

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

  963.         cy = y>>1;

  964.     } else {

  965.         cy = y;

  966.     }

  967. 

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

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

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

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

  972.         offset[i] = 0;

  973.     emms_c();

  974. 

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

  976. 

  977.     s->last_slice_end = y + h;

  978. }

  979. 

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

  981.                         AVPacket *avpkt)

  982. {

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

  984.     int buf_size = avpkt->size;

  985.     HYuvContext *s = avctx->priv_data;

  986.     const int width = s->width;

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

  988.     const int height = s->height;

  989.     int fake_ystride, fake_ustride, fake_vstride;

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

  991.     int table_size = 0;

  992. 

  993.     AVFrame *picture = data;

  994. 

  995.     av_fast_malloc(&s->bitstream_buffer,

  996.                    &s->bitstream_buffer_size,

  997.                    buf_size + FF_INPUT_BUFFER_PADDING_SIZE);

  998.     if (!s->bitstream_buffer)

  999.         return AVERROR(ENOMEM);

  1000. 

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

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

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

  1004. 

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

  1006.         ff_thread_release_buffer(avctx, p);

  1007. 

  1008.     p->reference = 0;

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

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

  1011.         return -1;

  1012.     }

  1013. 

  1014.     if (s->context) {

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

  1016.         if (table_size < 0)

  1017.             return -1;

  1018.     }

  1019. 

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

  1021.         return -1;

  1022. 

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

  1024.                   (buf_size-table_size) * 8);

  1025. 

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

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

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

  1029. 

  1030.     s->last_slice_end = 0;

  1031. 

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

  1033.         int y, cy;

  1034.         int lefty, leftu, leftv;

  1035.         int lefttopy, lefttopu, lefttopv;

  1036. 

  1037.         if (s->yuy2) {

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

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

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

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

  1042. 

  1043.             av_log(avctx, AV_LOG_ERROR,

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

  1045.             return -1;

  1046.         } else {

  1047. 

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

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

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

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

  1052. 

  1053.             switch (s->predictor) {

  1054.             case LEFT:

  1055.             case PLANE:

  1056.                 decode_422_bitstream(s, width-2);

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

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

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

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

  1061.                 }

  1062. 

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

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

  1065. 

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

  1067.                         decode_gray_bitstream(s, width);

  1068. 

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

  1070. 

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

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

  1073.                             if (y > s->interlaced)

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

  1075.                         }

  1076.                         y++;

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

  1078.                     }

  1079. 

  1080.                     draw_slice(s, y);

  1081. 

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

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

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

  1085. 

  1086.                     decode_422_bitstream(s, width);

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

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

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

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

  1091.                     }

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

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

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

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

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

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

  1098.                             }

  1099.                         }

  1100.                     }

  1101.                 }

  1102.                 draw_slice(s, height);

  1103. 

  1104.                 break;

  1105.             case MEDIAN:

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

  1107.                 decode_422_bitstream(s, width - 2);

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

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

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

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

  1112.                 }

  1113. 

  1114.                 cy = y = 1;

  1115. 

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

  1117.                 if (s->interlaced) {

  1118.                     decode_422_bitstream(s, width);

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

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

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

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

  1123.                     }

  1124.                     y++; cy++;

  1125.                 }

  1126. 

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

  1128.                 decode_422_bitstream(s, 4);

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

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

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

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

  1133.                 }

  1134. 

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

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

  1137.                 decode_422_bitstream(s, width - 4);

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

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

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

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

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

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

  1144.                 }

  1145.                 y++; cy++;

  1146. 

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

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

  1149. 

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

  1151.                         while (2 * cy > y) {

  1152.                             decode_gray_bitstream(s, width);

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

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

  1155.                             y++;

  1156.                         }

  1157.                         if (y >= height) break;

  1158.                     }

  1159.                     draw_slice(s, y);

  1160. 

  1161.                     decode_422_bitstream(s, width);

  1162. 

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

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

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

  1166. 

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

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

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

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

  1171.                     }

  1172.                 }

  1173. 

  1174.                 draw_slice(s, height);

  1175.                 break;

  1176.             }

  1177.         }

  1178.     } else {

  1179.         int y;

  1180.         int leftr, leftg, leftb, lefta;

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

  1182. 

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

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

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

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

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

  1188.         } else {

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

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

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

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

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

  1194.         }

  1195. 

  1196.         if (s->bgr32) {

  1197.             switch (s->predictor) {

  1198.             case LEFT:

  1199.             case PLANE:

  1200.                 decode_bgr_bitstream(s, width - 1);

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

  1202. 

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

  1204.                     decode_bgr_bitstream(s, width);

  1205. 

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

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

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

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

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

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

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

  1213.                                              fake_ystride, fake_ystride);

  1214.                         }

  1215.                     }

  1216.                 }

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

  1218.                 draw_slice(s, height);

  1219.                 break;

  1220.             default:

  1221.                 av_log(avctx, AV_LOG_ERROR,

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

  1223.             }

  1224.         }else{

  1225.             av_log(avctx, AV_LOG_ERROR,

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

  1227.             return -1;

  1228.         }

  1229.     }

  1230.     emms_c();

  1231. 

  1232.     *picture = *p;

  1233.     *data_size = sizeof(AVFrame);

  1234. 

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

  1236. }

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

  1238. 

  1239. static int common_end(HYuvContext *s)

  1240. {

  1241.     int i;

  1242. 

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

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

  1245.     }

  1246.     return 0;

  1247. }

  1248. 

  1249. #if CONFIG_HUFFYUV_DECODER || CONFIG_FFVHUFF_DECODER

  1250. static av_cold int decode_end(AVCodecContext *avctx)

  1251. {

  1252.     HYuvContext *s = avctx->priv_data;

  1253.     int i;

  1254. 

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

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

  1257. 

  1258.     common_end(s);

  1259.     av_freep(&s->bitstream_buffer);

  1260. 

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

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

  1263.     }

  1264. 

  1265.     return 0;

  1266. }

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

  1268. 

  1269. #if CONFIG_HUFFYUV_ENCODER || CONFIG_FFVHUFF_ENCODER

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

  1271.                         const AVFrame *pict, int *got_packet)

  1272. {

  1273.     HYuvContext *s = avctx->priv_data;

  1274.     const int width = s->width;

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

  1276.     const int height = s->height;

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

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

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

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

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

  1282. 

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

  1284.         return ret;

  1285. 

  1286.     *p = *pict;

  1287.     p->pict_type = AV_PICTURE_TYPE_I;

  1288.     p->key_frame = 1;

  1289. 

  1290.     if (s->context) {

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

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

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

  1294.                 return -1;

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

  1296.         }

  1297. 

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

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

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

  1301.     }

  1302. 

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

  1304. 

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

  1306.         avctx->pix_fmt == AV_PIX_FMT_YUV420P) {

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

  1308. 

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

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

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

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

  1313. 

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

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

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

  1317. 

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

  1319. 

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

  1321.             int lefttopy, lefttopu, lefttopv;

  1322.             cy = y = 1;

  1323.             if (s->interlaced) {

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

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

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

  1327. 

  1328.                 encode_422_bitstream(s, 0, width);

  1329.                 y++; cy++;

  1330.             }

  1331. 

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

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

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

  1335. 

  1336.             encode_422_bitstream(s, 0, 4);

  1337. 

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

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

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

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

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

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

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

  1345.             y++; cy++;

  1346. 

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

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

  1349. 

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

  1351.                     while (2 * cy > y) {

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

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

  1354.                         encode_gray_bitstream(s, width);

  1355.                         y++;

  1356.                     }

  1357.                     if (y >= height) break;

  1358.                 }

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

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

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

  1362. 

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

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

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

  1366. 

  1367.                 encode_422_bitstream(s, 0, width);

  1368.             }

  1369.         } else {

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

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

  1372. 

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

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

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

  1376. 

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

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

  1379. 

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

  1381.                     } else {

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

  1383.                     }

  1384.                     encode_gray_bitstream(s, width);

  1385.                     y++;

  1386.                     if (y >= height) break;

  1387.                 }

  1388. 

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

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

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

  1392. 

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

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

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

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

  1397. 

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

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

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

  1401.                 } else {

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

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

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

  1405.                 }

  1406. 

  1407.                 encode_422_bitstream(s, 0, width);

  1408.             }

  1409.         }

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

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

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

  1413.         const int fake_stride = -fake_ystride;

  1414.         int y;

  1415.         int leftr, leftg, leftb, lefta;

  1416. 

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

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

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

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

  1421. 

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

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

  1424. 

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

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

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

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

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

  1430.             } else {

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

  1432.             }

  1433.             encode_bgra_bitstream(s, width, 4);

  1434.         }

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

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

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

  1438.         const int fake_stride = -fake_ystride;

  1439.         int y;

  1440.         int leftr, leftg, leftb;

  1441. 

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

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

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

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

  1446. 

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

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

  1449. 

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

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

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

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

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

  1455.             }else{

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

  1457.             }

  1458.             encode_bgra_bitstream(s, width, 3);

  1459.         }

  1460.     } else {

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

  1462.     }

  1463.     emms_c();

  1464. 

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

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

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

  1468.     size /= 4;

  1469. 

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

  1471.         int j;

  1472.         char *p = avctx->stats_out;

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

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

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

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

  1477.                 p += strlen(p);

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

  1479.             }

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

  1481.             p++;

  1482.         }

  1483.     } else

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

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

  1486.         flush_put_bits(&s->pb);

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

  1488.     }

  1489. 

  1490.     s->picture_number++;

  1491. 

  1492.     pkt->size   = size * 4;

  1493.     pkt->flags |= AV_PKT_FLAG_KEY;

  1494.     *got_packet = 1;

  1495. 

  1496.     return 0;

  1497. }

  1498. 

  1499. static av_cold int encode_end(AVCodecContext *avctx)

  1500. {

  1501.     HYuvContext *s = avctx->priv_data;

  1502. 

  1503.     common_end(s);

  1504. 

  1505.     av_freep(&avctx->extradata);

  1506.     av_freep(&avctx->stats_out);

  1507. 

  1508.     return 0;

  1509. }

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

  1511. 

  1512. #if CONFIG_HUFFYUV_DECODER

  1513. AVCodec ff_huffyuv_decoder = {

  1514.     .name             = "huffyuv",

  1515.     .type             = AVMEDIA_TYPE_VIDEO,

  1516.     .id               = AV_CODEC_ID_HUFFYUV,

  1517.     .priv_data_size   = sizeof(HYuvContext),

  1518.     .init             = decode_init,

  1519.     .close            = decode_end,

  1520.     .decode           = decode_frame,

  1521.     .capabilities     = CODEC_CAP_DR1 | CODEC_CAP_DRAW_HORIZ_BAND |

  1522.                         CODEC_CAP_FRAME_THREADS,

  1523.     .init_thread_copy = ONLY_IF_THREADS_ENABLED(decode_init_thread_copy),

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

  1525. };

  1526. #endif

  1527. 

  1528. #if CONFIG_FFVHUFF_DECODER

  1529. AVCodec ff_ffvhuff_decoder = {

  1530.     .name             = "ffvhuff",

  1531.     .type             = AVMEDIA_TYPE_VIDEO,

  1532.     .id               = AV_CODEC_ID_FFVHUFF,

  1533.     .priv_data_size   = sizeof(HYuvContext),

  1534.     .init             = decode_init,

  1535.     .close            = decode_end,

  1536.     .decode           = decode_frame,

  1537.     .capabilities     = CODEC_CAP_DR1 | CODEC_CAP_DRAW_HORIZ_BAND |

  1538.                         CODEC_CAP_FRAME_THREADS,

  1539.     .init_thread_copy = ONLY_IF_THREADS_ENABLED(decode_init_thread_copy),

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

  1541. };

  1542. #endif

  1543. 

  1544. #if CONFIG_HUFFYUV_ENCODER

  1545. AVCodec ff_huffyuv_encoder = {

  1546.     .name           = "huffyuv",

  1547.     .type           = AVMEDIA_TYPE_VIDEO,

  1548.     .id             = AV_CODEC_ID_HUFFYUV,

  1549.     .priv_data_size = sizeof(HYuvContext),

  1550.     .init           = encode_init,

  1551.     .encode2        = encode_frame,

  1552.     .close          = encode_end,

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

  1554.         AV_PIX_FMT_YUV422P, AV_PIX_FMT_RGB24, AV_PIX_FMT_RGB32, AV_PIX_FMT_NONE

  1555.     },

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

  1557. };

  1558. #endif

  1559. 

  1560. #if CONFIG_FFVHUFF_ENCODER

  1561. AVCodec ff_ffvhuff_encoder = {

  1562.     .name           = "ffvhuff",

  1563.     .type           = AVMEDIA_TYPE_VIDEO,

  1564.     .id             = AV_CODEC_ID_FFVHUFF,

  1565.     .priv_data_size = sizeof(HYuvContext),

  1566.     .init           = encode_init,

  1567.     .encode2        = encode_frame,

  1568.     .close          = encode_end,

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

  1570.         AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_RGB24, AV_PIX_FMT_RGB32, AV_PIX_FMT_NONE

  1571.     },

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

  1573. };

  1574. #endif