FFmpeg: libavcodec/huffyuv.c Source File

00001 /*
00002  * huffyuv codec for libavcodec
00003  *
00004  * Copyright (c) 2002-2003 Michael Niedermayer <michaelni@gmx.at>
00005  *
00006  * see http://www.pcisys.net/~melanson/codecs/huffyuv.txt for a description of
00007  * the algorithm used
00008  *
00009  * This file is part of FFmpeg.
00010  *
00011  * FFmpeg is free software; you can redistribute it and/or
00012  * modify it under the terms of the GNU Lesser General Public
00013  * License as published by the Free Software Foundation; either
00014  * version 2.1 of the License, or (at your option) any later version.
00015  *
00016  * FFmpeg is distributed in the hope that it will be useful,
00017  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00018  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00019  * Lesser General Public License for more details.
00020  *
00021  * You should have received a copy of the GNU Lesser General Public
00022  * License along with FFmpeg; if not, write to the Free Software
00023  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
00024  */
00025 
00031 #include "avcodec.h"
00032 #include "get_bits.h"
00033 #include "put_bits.h"
00034 #include "dsputil.h"
00035 
00036 #define VLC_BITS 11
00037 
00038 #if HAVE_BIGENDIAN
00039 #define B 3
00040 #define G 2
00041 #define R 1
00042 #define A 0
00043 #else
00044 #define B 0
00045 #define G 1
00046 #define R 2
00047 #define A 3
00048 #endif
00049 
00050 typedef enum Predictor{
00051     LEFT= 0,
00052     PLANE,
00053     MEDIAN,
00054 } Predictor;
00055 
00056 typedef struct HYuvContext{
00057     AVCodecContext *avctx;
00058     Predictor predictor;
00059     GetBitContext gb;
00060     PutBitContext pb;
00061     int interlaced;
00062     int decorrelate;
00063     int bitstream_bpp;
00064     int version;
00065     int yuy2;                               //use yuy2 instead of 422P
00066     int bgr32;                              //use bgr32 instead of bgr24
00067     int width, height;
00068     int flags;
00069     int context;
00070     int picture_number;
00071     int last_slice_end;
00072     uint8_t *temp[3];
00073     uint64_t stats[3][256];
00074     uint8_t len[3][256];
00075     uint32_t bits[3][256];
00076     uint32_t pix_bgr_map[1<<VLC_BITS];
00077     VLC vlc[6];                             //Y,U,V,YY,YU,YV
00078     AVFrame picture;
00079     uint8_t *bitstream_buffer;
00080     unsigned int bitstream_buffer_size;
00081     DSPContext dsp;
00082 }HYuvContext;
00083 
00084 static const unsigned char classic_shift_luma[] = {
00085   34,36,35,69,135,232,9,16,10,24,11,23,12,16,13,10,14,8,15,8,
00086   16,8,17,20,16,10,207,206,205,236,11,8,10,21,9,23,8,8,199,70,
00087   69,68, 0
00088 };
00089 
00090 static const unsigned char classic_shift_chroma[] = {
00091   66,36,37,38,39,40,41,75,76,77,110,239,144,81,82,83,84,85,118,183,
00092   56,57,88,89,56,89,154,57,58,57,26,141,57,56,58,57,58,57,184,119,
00093   214,245,116,83,82,49,80,79,78,77,44,75,41,40,39,38,37,36,34, 0
00094 };
00095 
00096 static const unsigned char classic_add_luma[256] = {
00097     3,  9,  5, 12, 10, 35, 32, 29, 27, 50, 48, 45, 44, 41, 39, 37,
00098    73, 70, 68, 65, 64, 61, 58, 56, 53, 50, 49, 46, 44, 41, 38, 36,
00099    68, 65, 63, 61, 58, 55, 53, 51, 48, 46, 45, 43, 41, 39, 38, 36,
00100    35, 33, 32, 30, 29, 27, 26, 25, 48, 47, 46, 44, 43, 41, 40, 39,
00101    37, 36, 35, 34, 32, 31, 30, 28, 27, 26, 24, 23, 22, 20, 19, 37,
00102    35, 34, 33, 31, 30, 29, 27, 26, 24, 23, 21, 20, 18, 17, 15, 29,
00103    27, 26, 24, 22, 21, 19, 17, 16, 14, 26, 25, 23, 21, 19, 18, 16,
00104    15, 27, 25, 23, 21, 19, 17, 16, 14, 26, 25, 23, 21, 18, 17, 14,
00105    12, 17, 19, 13,  4,  9,  2, 11,  1,  7,  8,  0, 16,  3, 14,  6,
00106    12, 10,  5, 15, 18, 11, 10, 13, 15, 16, 19, 20, 22, 24, 27, 15,
00107    18, 20, 22, 24, 26, 14, 17, 20, 22, 24, 27, 15, 18, 20, 23, 25,
00108    28, 16, 19, 22, 25, 28, 32, 36, 21, 25, 29, 33, 38, 42, 45, 49,
00109    28, 31, 34, 37, 40, 42, 44, 47, 49, 50, 52, 54, 56, 57, 59, 60,
00110    62, 64, 66, 67, 69, 35, 37, 39, 40, 42, 43, 45, 47, 48, 51, 52,
00111    54, 55, 57, 59, 60, 62, 63, 66, 67, 69, 71, 72, 38, 40, 42, 43,
00112    46, 47, 49, 51, 26, 28, 30, 31, 33, 34, 18, 19, 11, 13,  7,  8,
00113 };
00114 
00115 static const unsigned char classic_add_chroma[256] = {
00116     3,  1,  2,  2,  2,  2,  3,  3,  7,  5,  7,  5,  8,  6, 11,  9,
00117     7, 13, 11, 10,  9,  8,  7,  5,  9,  7,  6,  4,  7,  5,  8,  7,
00118    11,  8, 13, 11, 19, 15, 22, 23, 20, 33, 32, 28, 27, 29, 51, 77,
00119    43, 45, 76, 81, 46, 82, 75, 55, 56,144, 58, 80, 60, 74,147, 63,
00120   143, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
00121    80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 27, 30, 21, 22,
00122    17, 14,  5,  6,100, 54, 47, 50, 51, 53,106,107,108,109,110,111,
00123   112,113,114,115,  4,117,118, 92, 94,121,122,  3,124,103,  2,  1,
00124     0,129,130,131,120,119,126,125,136,137,138,139,140,141,142,134,
00125   135,132,133,104, 64,101, 62, 57,102, 95, 93, 59, 61, 28, 97, 96,
00126    52, 49, 48, 29, 32, 25, 24, 46, 23, 98, 45, 44, 43, 20, 42, 41,
00127    19, 18, 99, 40, 15, 39, 38, 16, 13, 12, 11, 37, 10,  9,  8, 36,
00128     7,128,127,105,123,116, 35, 34, 33,145, 31, 79, 42,146, 78, 26,
00129    83, 48, 49, 50, 44, 47, 26, 31, 30, 18, 17, 19, 21, 24, 25, 13,
00130    14, 16, 17, 18, 20, 21, 12, 14, 15,  9, 10,  6,  9,  6,  5,  8,
00131     6, 12,  8, 10,  7,  9,  6,  4,  6,  2,  2,  3,  3,  3,  3,  2,
00132 };
00133 
00134 static inline int sub_left_prediction(HYuvContext *s, uint8_t *dst, uint8_t *src, int w, int left){
00135     int i;
00136     if(w<32){
00137         for(i=0; i<w; i++){
00138             const int temp= src[i];
00139             dst[i]= temp - left;
00140             left= temp;
00141         }
00142         return left;
00143     }else{
00144         for(i=0; i<16; i++){
00145             const int temp= src[i];
00146             dst[i]= temp - left;
00147             left= temp;
00148         }
00149         s->dsp.diff_bytes(dst+16, src+16, src+15, w-16);
00150         return src[w-1];
00151     }
00152 }
00153 
00154 static inline void sub_left_prediction_bgr32(HYuvContext *s, uint8_t *dst, uint8_t *src, int w, int *red, int *green, int *blue){
00155     int i;
00156     int r,g,b;
00157     r= *red;
00158     g= *green;
00159     b= *blue;
00160     for(i=0; i<FFMIN(w,4); i++){
00161         const int rt= src[i*4+R];
00162         const int gt= src[i*4+G];
00163         const int bt= src[i*4+B];
00164         dst[i*4+R]= rt - r;
00165         dst[i*4+G]= gt - g;
00166         dst[i*4+B]= bt - b;
00167         r = rt;
00168         g = gt;
00169         b = bt;
00170     }
00171     s->dsp.diff_bytes(dst+16, src+16, src+12, w*4-16);
00172     *red=   src[(w-1)*4+R];
00173     *green= src[(w-1)*4+G];
00174     *blue=  src[(w-1)*4+B];
00175 }
00176 
00177 static int read_len_table(uint8_t *dst, GetBitContext *gb){
00178     int i, val, repeat;
00179 
00180     for(i=0; i<256;){
00181         repeat= get_bits(gb, 3);
00182         val   = get_bits(gb, 5);
00183         if(repeat==0)
00184             repeat= get_bits(gb, 8);
00185 //printf("%d %d\n", val, repeat);
00186         if(i+repeat > 256) {
00187             av_log(NULL, AV_LOG_ERROR, "Error reading huffman table\n");
00188             return -1;
00189         }
00190         while (repeat--)
00191             dst[i++] = val;
00192     }
00193     return 0;
00194 }
00195 
00196 static int generate_bits_table(uint32_t *dst, const uint8_t *len_table){
00197     int len, index;
00198     uint32_t bits=0;
00199 
00200     for(len=32; len>0; len--){
00201         for(index=0; index<256; index++){
00202             if(len_table[index]==len)
00203                 dst[index]= bits++;
00204         }
00205         if(bits & 1){
00206             av_log(NULL, AV_LOG_ERROR, "Error generating huffman table\n");
00207             return -1;
00208         }
00209         bits >>= 1;
00210     }
00211     return 0;
00212 }
00213 
00214 #if CONFIG_HUFFYUV_ENCODER || CONFIG_FFVHUFF_ENCODER
00215 typedef struct {
00216     uint64_t val;
00217     int name;
00218 } HeapElem;
00219 
00220 static void heap_sift(HeapElem *h, int root, int size)
00221 {
00222     while(root*2+1 < size) {
00223         int child = root*2+1;
00224         if(child < size-1 && h[child].val > h[child+1].val)
00225             child++;
00226         if(h[root].val > h[child].val) {
00227             FFSWAP(HeapElem, h[root], h[child]);
00228             root = child;
00229         } else
00230             break;
00231     }
00232 }
00233 
00234 static void generate_len_table(uint8_t *dst, const uint64_t *stats){
00235     HeapElem h[256];
00236     int up[2*256];
00237     int len[2*256];
00238     int offset, i, next;
00239     int size = 256;
00240 
00241     for(offset=1; ; offset<<=1){
00242         for(i=0; i<size; i++){
00243             h[i].name = i;
00244             h[i].val = (stats[i] << 8) + offset;
00245         }
00246         for(i=size/2-1; i>=0; i--)
00247             heap_sift(h, i, size);
00248 
00249         for(next=size; next<size*2-1; next++){
00250             // merge the two smallest entries, and put it back in the heap
00251             uint64_t min1v = h[0].val;
00252             up[h[0].name] = next;
00253             h[0].val = INT64_MAX;
00254             heap_sift(h, 0, size);
00255             up[h[0].name] = next;
00256             h[0].name = next;
00257             h[0].val += min1v;
00258             heap_sift(h, 0, size);
00259         }
00260 
00261         len[2*size-2] = 0;
00262         for(i=2*size-3; i>=size; i--)
00263             len[i] = len[up[i]] + 1;
00264         for(i=0; i<size; i++) {
00265             dst[i] = len[up[i]] + 1;
00266             if(dst[i] >= 32) break;
00267         }
00268         if(i==size) break;
00269     }
00270 }
00271 #endif /* CONFIG_HUFFYUV_ENCODER || CONFIG_FFVHUFF_ENCODER */
00272 
00273 static void generate_joint_tables(HYuvContext *s){
00274     uint16_t symbols[1<<VLC_BITS];
00275     uint16_t bits[1<<VLC_BITS];
00276     uint8_t len[1<<VLC_BITS];
00277     if(s->bitstream_bpp < 24){
00278         int p, i, y, u;
00279         for(p=0; p<3; p++){
00280             for(i=y=0; y<256; y++){
00281                 int len0 = s->len[0][y];
00282                 int limit = VLC_BITS - len0;
00283                 if(limit <= 0)
00284                     continue;
00285                 for(u=0; u<256; u++){
00286                     int len1 = s->len[p][u];
00287                     if(len1 > limit)
00288                         continue;
00289                     len[i] = len0 + len1;
00290                     bits[i] = (s->bits[0][y] << len1) + s->bits[p][u];
00291                     symbols[i] = (y<<8) + u;
00292                     if(symbols[i] != 0xffff) // reserved to mean "invalid"
00293                         i++;
00294                 }
00295             }
00296             free_vlc(&s->vlc[3+p]);
00297             init_vlc_sparse(&s->vlc[3+p], VLC_BITS, i, len, 1, 1, bits, 2, 2, symbols, 2, 2, 0);
00298         }
00299     }else{
00300         uint8_t (*map)[4] = (uint8_t(*)[4])s->pix_bgr_map;
00301         int i, b, g, r, code;
00302         int p0 = s->decorrelate;
00303         int p1 = !s->decorrelate;
00304         // restrict the range to +/-16 becaues that's pretty much guaranteed to
00305         // cover all the combinations that fit in 11 bits total, and it doesn't
00306         // matter if we miss a few rare codes.
00307         for(i=0, g=-16; g<16; g++){
00308             int len0 = s->len[p0][g&255];
00309             int limit0 = VLC_BITS - len0;
00310             if(limit0 < 2)
00311                 continue;
00312             for(b=-16; b<16; b++){
00313                 int len1 = s->len[p1][b&255];
00314                 int limit1 = limit0 - len1;
00315                 if(limit1 < 1)
00316                     continue;
00317                 code = (s->bits[p0][g&255] << len1) + s->bits[p1][b&255];
00318                 for(r=-16; r<16; r++){
00319                     int len2 = s->len[2][r&255];
00320                     if(len2 > limit1)
00321                         continue;
00322                     len[i] = len0 + len1 + len2;
00323                     bits[i] = (code << len2) + s->bits[2][r&255];
00324                     if(s->decorrelate){
00325                         map[i][G] = g;
00326                         map[i][B] = g+b;
00327                         map[i][R] = g+r;
00328                     }else{
00329                         map[i][B] = g;
00330                         map[i][G] = b;
00331                         map[i][R] = r;
00332                     }
00333                     i++;
00334                 }
00335             }
00336         }
00337         free_vlc(&s->vlc[3]);
00338         init_vlc(&s->vlc[3], VLC_BITS, i, len, 1, 1, bits, 2, 2, 0);
00339     }
00340 }
00341 
00342 static int read_huffman_tables(HYuvContext *s, const uint8_t *src, int length){
00343     GetBitContext gb;
00344     int i;
00345 
00346     init_get_bits(&gb, src, length*8);
00347 
00348     for(i=0; i<3; i++){
00349         if(read_len_table(s->len[i], &gb)<0)
00350             return -1;
00351         if(generate_bits_table(s->bits[i], s->len[i])<0){
00352             return -1;
00353         }
00354 #if 0
00355 for(j=0; j<256; j++){
00356 printf("%6X, %2d,  %3d\n", s->bits[i][j], s->len[i][j], j);
00357 }
00358 #endif
00359         free_vlc(&s->vlc[i]);
00360         init_vlc(&s->vlc[i], VLC_BITS, 256, s->len[i], 1, 1, s->bits[i], 4, 4, 0);
00361     }
00362 
00363     generate_joint_tables(s);
00364 
00365     return (get_bits_count(&gb)+7)/8;
00366 }
00367 
00368 static int read_old_huffman_tables(HYuvContext *s){
00369 #if 1
00370     GetBitContext gb;
00371     int i;
00372 
00373     init_get_bits(&gb, classic_shift_luma, sizeof(classic_shift_luma)*8);
00374     if(read_len_table(s->len[0], &gb)<0)
00375         return -1;
00376     init_get_bits(&gb, classic_shift_chroma, sizeof(classic_shift_chroma)*8);
00377     if(read_len_table(s->len[1], &gb)<0)
00378         return -1;
00379 
00380     for(i=0; i<256; i++) s->bits[0][i] = classic_add_luma  [i];
00381     for(i=0; i<256; i++) s->bits[1][i] = classic_add_chroma[i];
00382 
00383     if(s->bitstream_bpp >= 24){
00384         memcpy(s->bits[1], s->bits[0], 256*sizeof(uint32_t));
00385         memcpy(s->len[1] , s->len [0], 256*sizeof(uint8_t));
00386     }
00387     memcpy(s->bits[2], s->bits[1], 256*sizeof(uint32_t));
00388     memcpy(s->len[2] , s->len [1], 256*sizeof(uint8_t));
00389 
00390     for(i=0; i<3; i++){
00391         free_vlc(&s->vlc[i]);
00392         init_vlc(&s->vlc[i], VLC_BITS, 256, s->len[i], 1, 1, s->bits[i], 4, 4, 0);
00393     }
00394 
00395     generate_joint_tables(s);
00396 
00397     return 0;
00398 #else
00399     av_log(s->avctx, AV_LOG_DEBUG, "v1 huffyuv is not supported \n");
00400     return -1;
00401 #endif
00402 }
00403 
00404 static av_cold void alloc_temp(HYuvContext *s){
00405     int i;
00406 
00407     if(s->bitstream_bpp<24){
00408         for(i=0; i<3; i++){
00409             s->temp[i]= av_malloc(s->width + 16);
00410         }
00411     }else{
00412         s->temp[0]= av_mallocz(4*s->width + 16);
00413     }
00414 }
00415 
00416 static av_cold int common_init(AVCodecContext *avctx){
00417     HYuvContext *s = avctx->priv_data;
00418 
00419     s->avctx= avctx;
00420     s->flags= avctx->flags;
00421 
00422     dsputil_init(&s->dsp, avctx);
00423 
00424     s->width= avctx->width;
00425     s->height= avctx->height;
00426     assert(s->width>0 && s->height>0);
00427 
00428     return 0;
00429 }
00430 
00431 #if CONFIG_HUFFYUV_DECODER || CONFIG_FFVHUFF_DECODER
00432 static av_cold int decode_init(AVCodecContext *avctx)
00433 {
00434     HYuvContext *s = avctx->priv_data;
00435 
00436     common_init(avctx);
00437     memset(s->vlc, 0, 3*sizeof(VLC));
00438 
00439     avctx->coded_frame= &s->picture;
00440     s->interlaced= s->height > 288;
00441 
00442 s->bgr32=1;
00443 //if(avctx->extradata)
00444 //  printf("extradata:%X, extradata_size:%d\n", *(uint32_t*)avctx->extradata, avctx->extradata_size);
00445     if(avctx->extradata_size){
00446         if((avctx->bits_per_coded_sample&7) && avctx->bits_per_coded_sample != 12)
00447             s->version=1; // do such files exist at all?
00448         else
00449             s->version=2;
00450     }else
00451         s->version=0;
00452 
00453     if(s->version==2){
00454         int method, interlace;
00455 
00456         if (avctx->extradata_size < 4)
00457             return -1;
00458 
00459         method= ((uint8_t*)avctx->extradata)[0];
00460         s->decorrelate= method&64 ? 1 : 0;
00461         s->predictor= method&63;
00462         s->bitstream_bpp= ((uint8_t*)avctx->extradata)[1];
00463         if(s->bitstream_bpp==0)
00464             s->bitstream_bpp= avctx->bits_per_coded_sample&~7;
00465         interlace= (((uint8_t*)avctx->extradata)[2] & 0x30) >> 4;
00466         s->interlaced= (interlace==1) ? 1 : (interlace==2) ? 0 : s->interlaced;
00467         s->context= ((uint8_t*)avctx->extradata)[2] & 0x40 ? 1 : 0;
00468 
00469         if(read_huffman_tables(s, ((uint8_t*)avctx->extradata)+4, avctx->extradata_size-4) < 0)
00470             return -1;
00471     }else{
00472         switch(avctx->bits_per_coded_sample&7){
00473         case 1:
00474             s->predictor= LEFT;
00475             s->decorrelate= 0;
00476             break;
00477         case 2:
00478             s->predictor= LEFT;
00479             s->decorrelate= 1;
00480             break;
00481         case 3:
00482             s->predictor= PLANE;
00483             s->decorrelate= avctx->bits_per_coded_sample >= 24;
00484             break;
00485         case 4:
00486             s->predictor= MEDIAN;
00487             s->decorrelate= 0;
00488             break;
00489         default:
00490             s->predictor= LEFT; //OLD
00491             s->decorrelate= 0;
00492             break;
00493         }
00494         s->bitstream_bpp= avctx->bits_per_coded_sample & ~7;
00495         s->context= 0;
00496 
00497         if(read_old_huffman_tables(s) < 0)
00498             return -1;
00499     }
00500 
00501     switch(s->bitstream_bpp){
00502     case 12:
00503         avctx->pix_fmt = PIX_FMT_YUV420P;
00504         break;
00505     case 16:
00506         if(s->yuy2){
00507             avctx->pix_fmt = PIX_FMT_YUYV422;
00508         }else{
00509             avctx->pix_fmt = PIX_FMT_YUV422P;
00510         }
00511         break;
00512     case 24:
00513     case 32:
00514         if(s->bgr32){
00515             avctx->pix_fmt = PIX_FMT_RGB32;
00516         }else{
00517             avctx->pix_fmt = PIX_FMT_BGR24;
00518         }
00519         break;
00520     default:
00521         assert(0);
00522     }
00523 
00524     alloc_temp(s);
00525 
00526 //    av_log(NULL, AV_LOG_DEBUG, "pred:%d bpp:%d hbpp:%d il:%d\n", s->predictor, s->bitstream_bpp, avctx->bits_per_coded_sample, s->interlaced);
00527 
00528     return 0;
00529 }
00530 #endif /* CONFIG_HUFFYUV_DECODER || CONFIG_FFVHUFF_DECODER */
00531 
00532 #if CONFIG_HUFFYUV_ENCODER || CONFIG_FFVHUFF_ENCODER
00533 static int store_table(HYuvContext *s, const uint8_t *len, uint8_t *buf){
00534     int i;
00535     int index= 0;
00536 
00537     for(i=0; i<256;){
00538         int val= len[i];
00539         int repeat=0;
00540 
00541         for(; i<256 && len[i]==val && repeat<255; i++)
00542             repeat++;
00543 
00544         assert(val < 32 && val >0 && repeat<256 && repeat>0);
00545         if(repeat>7){
00546             buf[index++]= val;
00547             buf[index++]= repeat;
00548         }else{
00549             buf[index++]= val | (repeat<<5);
00550         }
00551     }
00552 
00553     return index;
00554 }
00555 
00556 static av_cold int encode_init(AVCodecContext *avctx)
00557 {
00558     HYuvContext *s = avctx->priv_data;
00559     int i, j;
00560 
00561     common_init(avctx);
00562 
00563     avctx->extradata= av_mallocz(1024*30); // 256*3+4 == 772
00564     avctx->stats_out= av_mallocz(1024*30); // 21*256*3(%llu ) + 3(\n) + 1(0) = 16132
00565     s->version=2;
00566 
00567     avctx->coded_frame= &s->picture;
00568 
00569     switch(avctx->pix_fmt){
00570     case PIX_FMT_YUV420P:
00571         s->bitstream_bpp= 12;
00572         break;
00573     case PIX_FMT_YUV422P:
00574         s->bitstream_bpp= 16;
00575         break;
00576     case PIX_FMT_RGB32:
00577         s->bitstream_bpp= 24;
00578         break;
00579     default:
00580         av_log(avctx, AV_LOG_ERROR, "format not supported\n");
00581         return -1;
00582     }
00583     avctx->bits_per_coded_sample= s->bitstream_bpp;
00584     s->decorrelate= s->bitstream_bpp >= 24;
00585     s->predictor= avctx->prediction_method;
00586     s->interlaced= avctx->flags&CODEC_FLAG_INTERLACED_ME ? 1 : 0;
00587     if(avctx->context_model==1){
00588         s->context= avctx->context_model;
00589         if(s->flags & (CODEC_FLAG_PASS1|CODEC_FLAG_PASS2)){
00590             av_log(avctx, AV_LOG_ERROR, "context=1 is not compatible with 2 pass huffyuv encoding\n");
00591             return -1;
00592         }
00593     }else s->context= 0;
00594 
00595     if(avctx->codec->id==CODEC_ID_HUFFYUV){
00596         if(avctx->pix_fmt==PIX_FMT_YUV420P){
00597             av_log(avctx, AV_LOG_ERROR, "Error: YV12 is not supported by huffyuv; use vcodec=ffvhuff or format=422p\n");
00598             return -1;
00599         }
00600         if(avctx->context_model){
00601             av_log(avctx, AV_LOG_ERROR, "Error: per-frame huffman tables are not supported by huffyuv; use vcodec=ffvhuff\n");
00602             return -1;
00603         }
00604         if(s->interlaced != ( s->height > 288 ))
00605             av_log(avctx, AV_LOG_INFO, "using huffyuv 2.2.0 or newer interlacing flag\n");
00606     }
00607 
00608     if(s->bitstream_bpp>=24 && s->predictor==MEDIAN){
00609         av_log(avctx, AV_LOG_ERROR, "Error: RGB is incompatible with median predictor\n");
00610         return -1;
00611     }
00612 
00613     ((uint8_t*)avctx->extradata)[0]= s->predictor | (s->decorrelate << 6);
00614     ((uint8_t*)avctx->extradata)[1]= s->bitstream_bpp;
00615     ((uint8_t*)avctx->extradata)[2]= s->interlaced ? 0x10 : 0x20;
00616     if(s->context)
00617         ((uint8_t*)avctx->extradata)[2]|= 0x40;
00618     ((uint8_t*)avctx->extradata)[3]= 0;
00619     s->avctx->extradata_size= 4;
00620 
00621     if(avctx->stats_in){
00622         char *p= avctx->stats_in;
00623 
00624         for(i=0; i<3; i++)
00625             for(j=0; j<256; j++)
00626                 s->stats[i][j]= 1;
00627 
00628         for(;;){
00629             for(i=0; i<3; i++){
00630                 char *next;
00631 
00632                 for(j=0; j<256; j++){
00633                     s->stats[i][j]+= strtol(p, &next, 0);
00634                     if(next==p) return -1;
00635                     p=next;
00636                 }
00637             }
00638             if(p[0]==0 || p[1]==0 || p[2]==0) break;
00639         }
00640     }else{
00641         for(i=0; i<3; i++)
00642             for(j=0; j<256; j++){
00643                 int d= FFMIN(j, 256-j);
00644 
00645                 s->stats[i][j]= 100000000/(d+1);
00646             }
00647     }
00648 
00649     for(i=0; i<3; i++){
00650         generate_len_table(s->len[i], s->stats[i]);
00651 
00652         if(generate_bits_table(s->bits[i], s->len[i])<0){
00653             return -1;
00654         }
00655 
00656         s->avctx->extradata_size+=
00657         store_table(s, s->len[i], &((uint8_t*)s->avctx->extradata)[s->avctx->extradata_size]);
00658     }
00659 
00660     if(s->context){
00661         for(i=0; i<3; i++){
00662             int pels = s->width*s->height / (i?40:10);
00663             for(j=0; j<256; j++){
00664                 int d= FFMIN(j, 256-j);
00665                 s->stats[i][j]= pels/(d+1);
00666             }
00667         }
00668     }else{
00669         for(i=0; i<3; i++)
00670             for(j=0; j<256; j++)
00671                 s->stats[i][j]= 0;
00672     }
00673 
00674 //    printf("pred:%d bpp:%d hbpp:%d il:%d\n", s->predictor, s->bitstream_bpp, avctx->bits_per_coded_sample, s->interlaced);
00675 
00676     alloc_temp(s);
00677 
00678     s->picture_number=0;
00679 
00680     return 0;
00681 }
00682 #endif /* CONFIG_HUFFYUV_ENCODER || CONFIG_FFVHUFF_ENCODER */
00683 
00684 /* TODO instead of restarting the read when the code isn't in the first level
00685  * of the joint table, jump into the 2nd level of the individual table. */
00686 #define READ_2PIX(dst0, dst1, plane1){\
00687     uint16_t code = get_vlc2(&s->gb, s->vlc[3+plane1].table, VLC_BITS, 1);\
00688     if(code != 0xffff){\
00689         dst0 = code>>8;\
00690         dst1 = code;\
00691     }else{\
00692         dst0 = get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3);\
00693         dst1 = get_vlc2(&s->gb, s->vlc[plane1].table, VLC_BITS, 3);\
00694     }\
00695 }
00696 
00697 static void decode_422_bitstream(HYuvContext *s, int count){
00698     int i;
00699 
00700     count/=2;
00701 
00702     if(count >= (get_bits_left(&s->gb))/(31*4)){
00703         for(i=0; i<count && get_bits_count(&s->gb) < s->gb.size_in_bits; i++){
00704             READ_2PIX(s->temp[0][2*i  ], s->temp[1][i], 1);
00705             READ_2PIX(s->temp[0][2*i+1], s->temp[2][i], 2);
00706         }
00707     }else{
00708         for(i=0; i<count; i++){
00709             READ_2PIX(s->temp[0][2*i  ], s->temp[1][i], 1);
00710             READ_2PIX(s->temp[0][2*i+1], s->temp[2][i], 2);
00711         }
00712     }
00713 }
00714 
00715 static void decode_gray_bitstream(HYuvContext *s, int count){
00716     int i;
00717 
00718     count/=2;
00719 
00720     if(count >= (get_bits_left(&s->gb))/(31*2)){
00721         for(i=0; i<count && get_bits_count(&s->gb) < s->gb.size_in_bits; i++){
00722             READ_2PIX(s->temp[0][2*i  ], s->temp[0][2*i+1], 0);
00723         }
00724     }else{
00725         for(i=0; i<count; i++){
00726             READ_2PIX(s->temp[0][2*i  ], s->temp[0][2*i+1], 0);
00727         }
00728     }
00729 }
00730 
00731 #if CONFIG_HUFFYUV_ENCODER || CONFIG_FFVHUFF_ENCODER
00732 static int encode_422_bitstream(HYuvContext *s, int offset, int count){
00733     int i;
00734     const uint8_t *y = s->temp[0] + offset;
00735     const uint8_t *u = s->temp[1] + offset/2;
00736     const uint8_t *v = s->temp[2] + offset/2;
00737 
00738     if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < 2*4*count){
00739         av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
00740         return -1;
00741     }
00742 
00743 #define LOAD4\
00744             int y0 = y[2*i];\
00745             int y1 = y[2*i+1];\
00746             int u0 = u[i];\
00747             int v0 = v[i];
00748 
00749     count/=2;
00750     if(s->flags&CODEC_FLAG_PASS1){
00751         for(i=0; i<count; i++){
00752             LOAD4;
00753             s->stats[0][y0]++;
00754             s->stats[1][u0]++;
00755             s->stats[0][y1]++;
00756             s->stats[2][v0]++;
00757         }
00758     }
00759     if(s->avctx->flags2&CODEC_FLAG2_NO_OUTPUT)
00760         return 0;
00761     if(s->context){
00762         for(i=0; i<count; i++){
00763             LOAD4;
00764             s->stats[0][y0]++;
00765             put_bits(&s->pb, s->len[0][y0], s->bits[0][y0]);
00766             s->stats[1][u0]++;
00767             put_bits(&s->pb, s->len[1][u0], s->bits[1][u0]);
00768             s->stats[0][y1]++;
00769             put_bits(&s->pb, s->len[0][y1], s->bits[0][y1]);
00770             s->stats[2][v0]++;
00771             put_bits(&s->pb, s->len[2][v0], s->bits[2][v0]);
00772         }
00773     }else{
00774         for(i=0; i<count; i++){
00775             LOAD4;
00776             put_bits(&s->pb, s->len[0][y0], s->bits[0][y0]);
00777             put_bits(&s->pb, s->len[1][u0], s->bits[1][u0]);
00778             put_bits(&s->pb, s->len[0][y1], s->bits[0][y1]);
00779             put_bits(&s->pb, s->len[2][v0], s->bits[2][v0]);
00780         }
00781     }
00782     return 0;
00783 }
00784 
00785 static int encode_gray_bitstream(HYuvContext *s, int count){
00786     int i;
00787 
00788     if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < 4*count){
00789         av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
00790         return -1;
00791     }
00792 
00793 #define LOAD2\
00794             int y0 = s->temp[0][2*i];\
00795             int y1 = s->temp[0][2*i+1];
00796 #define STAT2\
00797             s->stats[0][y0]++;\
00798             s->stats[0][y1]++;
00799 #define WRITE2\
00800             put_bits(&s->pb, s->len[0][y0], s->bits[0][y0]);\
00801             put_bits(&s->pb, s->len[0][y1], s->bits[0][y1]);
00802 
00803     count/=2;
00804     if(s->flags&CODEC_FLAG_PASS1){
00805         for(i=0; i<count; i++){
00806             LOAD2;
00807             STAT2;
00808         }
00809     }
00810     if(s->avctx->flags2&CODEC_FLAG2_NO_OUTPUT)
00811         return 0;
00812 
00813     if(s->context){
00814         for(i=0; i<count; i++){
00815             LOAD2;
00816             STAT2;
00817             WRITE2;
00818         }
00819     }else{
00820         for(i=0; i<count; i++){
00821             LOAD2;
00822             WRITE2;
00823         }
00824     }
00825     return 0;
00826 }
00827 #endif /* CONFIG_HUFFYUV_ENCODER || CONFIG_FFVHUFF_ENCODER */
00828 
00829 static av_always_inline void decode_bgr_1(HYuvContext *s, int count, int decorrelate, int alpha){
00830     int i;
00831     for(i=0; i<count; i++){
00832         int code = get_vlc2(&s->gb, s->vlc[3].table, VLC_BITS, 1);
00833         if(code != -1){
00834             *(uint32_t*)&s->temp[0][4*i] = s->pix_bgr_map[code];
00835         }else if(decorrelate){
00836             s->temp[0][4*i+G] = get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3);
00837             s->temp[0][4*i+B] = get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3) + s->temp[0][4*i+G];
00838             s->temp[0][4*i+R] = get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3) + s->temp[0][4*i+G];
00839         }else{
00840             s->temp[0][4*i+B] = get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3);
00841             s->temp[0][4*i+G] = get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3);
00842             s->temp[0][4*i+R] = get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3);
00843         }
00844         if(alpha)
00845             s->temp[0][4*i+A] = get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3);
00846     }
00847 }
00848 
00849 static void decode_bgr_bitstream(HYuvContext *s, int count){
00850     if(s->decorrelate){
00851         if(s->bitstream_bpp==24)
00852             decode_bgr_1(s, count, 1, 0);
00853         else
00854             decode_bgr_1(s, count, 1, 1);
00855     }else{
00856         if(s->bitstream_bpp==24)
00857             decode_bgr_1(s, count, 0, 0);
00858         else
00859             decode_bgr_1(s, count, 0, 1);
00860     }
00861 }
00862 
00863 static int encode_bgr_bitstream(HYuvContext *s, int count){
00864     int i;
00865 
00866     if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < 3*4*count){
00867         av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
00868         return -1;
00869     }
00870 
00871 #define LOAD3\
00872             int g= s->temp[0][4*i+G];\
00873             int b= (s->temp[0][4*i+B] - g) & 0xff;\
00874             int r= (s->temp[0][4*i+R] - g) & 0xff;
00875 #define STAT3\
00876             s->stats[0][b]++;\
00877             s->stats[1][g]++;\
00878             s->stats[2][r]++;
00879 #define WRITE3\
00880             put_bits(&s->pb, s->len[1][g], s->bits[1][g]);\
00881             put_bits(&s->pb, s->len[0][b], s->bits[0][b]);\
00882             put_bits(&s->pb, s->len[2][r], s->bits[2][r]);
00883 
00884     if((s->flags&CODEC_FLAG_PASS1) && (s->avctx->flags2&CODEC_FLAG2_NO_OUTPUT)){
00885         for(i=0; i<count; i++){
00886             LOAD3;
00887             STAT3;
00888         }
00889     }else if(s->context || (s->flags&CODEC_FLAG_PASS1)){
00890         for(i=0; i<count; i++){
00891             LOAD3;
00892             STAT3;
00893             WRITE3;
00894         }
00895     }else{
00896         for(i=0; i<count; i++){
00897             LOAD3;
00898             WRITE3;
00899         }
00900     }
00901     return 0;
00902 }
00903 
00904 #if CONFIG_HUFFYUV_DECODER || CONFIG_FFVHUFF_DECODER
00905 static void draw_slice(HYuvContext *s, int y){
00906     int h, cy;
00907     int offset[4];
00908 
00909     if(s->avctx->draw_horiz_band==NULL)
00910         return;
00911 
00912     h= y - s->last_slice_end;
00913     y -= h;
00914 
00915     if(s->bitstream_bpp==12){
00916         cy= y>>1;
00917     }else{
00918         cy= y;
00919     }
00920 
00921     offset[0] = s->picture.linesize[0]*y;
00922     offset[1] = s->picture.linesize[1]*cy;
00923     offset[2] = s->picture.linesize[2]*cy;
00924     offset[3] = 0;
00925     emms_c();
00926 
00927     s->avctx->draw_horiz_band(s->avctx, &s->picture, offset, y, 3, h);
00928 
00929     s->last_slice_end= y + h;
00930 }
00931 
00932 static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt){
00933     const uint8_t *buf = avpkt->data;
00934     int buf_size = avpkt->size;
00935     HYuvContext *s = avctx->priv_data;
00936     const int width= s->width;
00937     const int width2= s->width>>1;
00938     const int height= s->height;
00939     int fake_ystride, fake_ustride, fake_vstride;
00940     AVFrame * const p= &s->picture;
00941     int table_size= 0;
00942 
00943     AVFrame *picture = data;
00944 
00945     av_fast_malloc(&s->bitstream_buffer, &s->bitstream_buffer_size, buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
00946     if (!s->bitstream_buffer)
00947         return AVERROR(ENOMEM);
00948 
00949     memset(s->bitstream_buffer + buf_size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
00950     s->dsp.bswap_buf((uint32_t*)s->bitstream_buffer, (const uint32_t*)buf, buf_size/4);
00951 
00952     if(p->data[0])
00953         avctx->release_buffer(avctx, p);
00954 
00955     p->reference= 0;
00956     if(avctx->get_buffer(avctx, p) < 0){
00957         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
00958         return -1;
00959     }
00960 
00961     if(s->context){
00962         table_size = read_huffman_tables(s, s->bitstream_buffer, buf_size);
00963         if(table_size < 0)
00964             return -1;
00965     }
00966 
00967     if((unsigned)(buf_size-table_size) >= INT_MAX/8)
00968         return -1;
00969 
00970     init_get_bits(&s->gb, s->bitstream_buffer+table_size, (buf_size-table_size)*8);
00971 
00972     fake_ystride= s->interlaced ? p->linesize[0]*2  : p->linesize[0];
00973     fake_ustride= s->interlaced ? p->linesize[1]*2  : p->linesize[1];
00974     fake_vstride= s->interlaced ? p->linesize[2]*2  : p->linesize[2];
00975 
00976     s->last_slice_end= 0;
00977 
00978     if(s->bitstream_bpp<24){
00979         int y, cy;
00980         int lefty, leftu, leftv;
00981         int lefttopy, lefttopu, lefttopv;
00982 
00983         if(s->yuy2){
00984             p->data[0][3]= get_bits(&s->gb, 8);
00985             p->data[0][2]= get_bits(&s->gb, 8);
00986             p->data[0][1]= get_bits(&s->gb, 8);
00987             p->data[0][0]= get_bits(&s->gb, 8);
00988 
00989             av_log(avctx, AV_LOG_ERROR, "YUY2 output is not implemented yet\n");
00990             return -1;
00991         }else{
00992 
00993             leftv= p->data[2][0]= get_bits(&s->gb, 8);
00994             lefty= p->data[0][1]= get_bits(&s->gb, 8);
00995             leftu= p->data[1][0]= get_bits(&s->gb, 8);
00996                    p->data[0][0]= get_bits(&s->gb, 8);
00997 
00998             switch(s->predictor){
00999             case LEFT:
01000             case PLANE:
01001                 decode_422_bitstream(s, width-2);
01002                 lefty= s->dsp.add_hfyu_left_prediction(p->data[0] + 2, s->temp[0], width-2, lefty);
01003                 if(!(s->flags&CODEC_FLAG_GRAY)){
01004                     leftu= s->dsp.add_hfyu_left_prediction(p->data[1] + 1, s->temp[1], width2-1, leftu);
01005                     leftv= s->dsp.add_hfyu_left_prediction(p->data[2] + 1, s->temp[2], width2-1, leftv);
01006                 }
01007 
01008                 for(cy=y=1; y<s->height; y++,cy++){
01009                     uint8_t *ydst, *udst, *vdst;
01010 
01011                     if(s->bitstream_bpp==12){
01012                         decode_gray_bitstream(s, width);
01013 
01014                         ydst= p->data[0] + p->linesize[0]*y;
01015 
01016                         lefty= s->dsp.add_hfyu_left_prediction(ydst, s->temp[0], width, lefty);
01017                         if(s->predictor == PLANE){
01018                             if(y>s->interlaced)
01019                                 s->dsp.add_bytes(ydst, ydst - fake_ystride, width);
01020                         }
01021                         y++;
01022                         if(y>=s->height) break;
01023                     }
01024 
01025                     draw_slice(s, y);
01026 
01027                     ydst= p->data[0] + p->linesize[0]*y;
01028                     udst= p->data[1] + p->linesize[1]*cy;
01029                     vdst= p->data[2] + p->linesize[2]*cy;
01030 
01031                     decode_422_bitstream(s, width);
01032                     lefty= s->dsp.add_hfyu_left_prediction(ydst, s->temp[0], width, lefty);
01033                     if(!(s->flags&CODEC_FLAG_GRAY)){
01034                         leftu= s->dsp.add_hfyu_left_prediction(udst, s->temp[1], width2, leftu);
01035                         leftv= s->dsp.add_hfyu_left_prediction(vdst, s->temp[2], width2, leftv);
01036                     }
01037                     if(s->predictor == PLANE){
01038                         if(cy>s->interlaced){
01039                             s->dsp.add_bytes(ydst, ydst - fake_ystride, width);
01040                             if(!(s->flags&CODEC_FLAG_GRAY)){
01041                                 s->dsp.add_bytes(udst, udst - fake_ustride, width2);
01042                                 s->dsp.add_bytes(vdst, vdst - fake_vstride, width2);
01043                             }
01044                         }
01045                     }
01046                 }
01047                 draw_slice(s, height);
01048 
01049                 break;
01050             case MEDIAN:
01051                 /* first line except first 2 pixels is left predicted */
01052                 decode_422_bitstream(s, width-2);
01053                 lefty= s->dsp.add_hfyu_left_prediction(p->data[0] + 2, s->temp[0], width-2, lefty);
01054                 if(!(s->flags&CODEC_FLAG_GRAY)){
01055                     leftu= s->dsp.add_hfyu_left_prediction(p->data[1] + 1, s->temp[1], width2-1, leftu);
01056                     leftv= s->dsp.add_hfyu_left_prediction(p->data[2] + 1, s->temp[2], width2-1, leftv);
01057                 }
01058 
01059                 cy=y=1;
01060 
01061                 /* second line is left predicted for interlaced case */
01062                 if(s->interlaced){
01063                     decode_422_bitstream(s, width);
01064                     lefty= s->dsp.add_hfyu_left_prediction(p->data[0] + p->linesize[0], s->temp[0], width, lefty);
01065                     if(!(s->flags&CODEC_FLAG_GRAY)){
01066                         leftu= s->dsp.add_hfyu_left_prediction(p->data[1] + p->linesize[2], s->temp[1], width2, leftu);
01067                         leftv= s->dsp.add_hfyu_left_prediction(p->data[2] + p->linesize[1], s->temp[2], width2, leftv);
01068                     }
01069                     y++; cy++;
01070                 }
01071 
01072                 /* next 4 pixels are left predicted too */
01073                 decode_422_bitstream(s, 4);
01074                 lefty= s->dsp.add_hfyu_left_prediction(p->data[0] + fake_ystride, s->temp[0], 4, lefty);
01075                 if(!(s->flags&CODEC_FLAG_GRAY)){
01076                     leftu= s->dsp.add_hfyu_left_prediction(p->data[1] + fake_ustride, s->temp[1], 2, leftu);
01077                     leftv= s->dsp.add_hfyu_left_prediction(p->data[2] + fake_vstride, s->temp[2], 2, leftv);
01078                 }
01079 
01080                 /* next line except the first 4 pixels is median predicted */
01081                 lefttopy= p->data[0][3];
01082                 decode_422_bitstream(s, width-4);
01083                 s->dsp.add_hfyu_median_prediction(p->data[0] + fake_ystride+4, p->data[0]+4, s->temp[0], width-4, &lefty, &lefttopy);
01084                 if(!(s->flags&CODEC_FLAG_GRAY)){
01085                     lefttopu= p->data[1][1];
01086                     lefttopv= p->data[2][1];
01087                     s->dsp.add_hfyu_median_prediction(p->data[1] + fake_ustride+2, p->data[1]+2, s->temp[1], width2-2, &leftu, &lefttopu);
01088                     s->dsp.add_hfyu_median_prediction(p->data[2] + fake_vstride+2, p->data[2]+2, s->temp[2], width2-2, &leftv, &lefttopv);
01089                 }
01090                 y++; cy++;
01091 
01092                 for(; y<height; y++,cy++){
01093                     uint8_t *ydst, *udst, *vdst;
01094 
01095                     if(s->bitstream_bpp==12){
01096                         while(2*cy > y){
01097                             decode_gray_bitstream(s, width);
01098                             ydst= p->data[0] + p->linesize[0]*y;
01099                             s->dsp.add_hfyu_median_prediction(ydst, ydst - fake_ystride, s->temp[0], width, &lefty, &lefttopy);
01100                             y++;
01101                         }
01102                         if(y>=height) break;
01103                     }
01104                     draw_slice(s, y);
01105 
01106                     decode_422_bitstream(s, width);
01107 
01108                     ydst= p->data[0] + p->linesize[0]*y;
01109                     udst= p->data[1] + p->linesize[1]*cy;
01110                     vdst= p->data[2] + p->linesize[2]*cy;
01111 
01112                     s->dsp.add_hfyu_median_prediction(ydst, ydst - fake_ystride, s->temp[0], width, &lefty, &lefttopy);
01113                     if(!(s->flags&CODEC_FLAG_GRAY)){
01114                         s->dsp.add_hfyu_median_prediction(udst, udst - fake_ustride, s->temp[1], width2, &leftu, &lefttopu);
01115                         s->dsp.add_hfyu_median_prediction(vdst, vdst - fake_vstride, s->temp[2], width2, &leftv, &lefttopv);
01116                     }
01117                 }
01118 
01119                 draw_slice(s, height);
01120                 break;
01121             }
01122         }
01123     }else{
01124         int y;
01125         int leftr, leftg, leftb, lefta;
01126         const int last_line= (height-1)*p->linesize[0];
01127 
01128         if(s->bitstream_bpp==32){
01129             lefta= p->data[0][last_line+A]= get_bits(&s->gb, 8);
01130             leftr= p->data[0][last_line+R]= get_bits(&s->gb, 8);
01131             leftg= p->data[0][last_line+G]= get_bits(&s->gb, 8);
01132             leftb= p->data[0][last_line+B]= get_bits(&s->gb, 8);
01133         }else{
01134             leftr= p->data[0][last_line+R]= get_bits(&s->gb, 8);
01135             leftg= p->data[0][last_line+G]= get_bits(&s->gb, 8);
01136             leftb= p->data[0][last_line+B]= get_bits(&s->gb, 8);
01137             lefta= p->data[0][last_line+A]= 255;
01138             skip_bits(&s->gb, 8);
01139         }
01140 
01141         if(s->bgr32){
01142             switch(s->predictor){
01143             case LEFT:
01144             case PLANE:
01145                 decode_bgr_bitstream(s, width-1);
01146                 s->dsp.add_hfyu_left_prediction_bgr32(p->data[0] + last_line+4, s->temp[0], width-1, &leftr, &leftg, &leftb, &lefta);
01147 
01148                 for(y=s->height-2; y>=0; y--){ //Yes it is stored upside down.
01149                     decode_bgr_bitstream(s, width);
01150 
01151                     s->dsp.add_hfyu_left_prediction_bgr32(p->data[0] + p->linesize[0]*y, s->temp[0], width, &leftr, &leftg, &leftb, &lefta);
01152                     if(s->predictor == PLANE){
01153                         if(s->bitstream_bpp!=32) lefta=0;
01154                         if((y&s->interlaced)==0 && y<s->height-1-s->interlaced){
01155                             s->dsp.add_bytes(p->data[0] + p->linesize[0]*y,
01156                                              p->data[0] + p->linesize[0]*y + fake_ystride, fake_ystride);
01157                         }
01158                     }
01159                 }
01160                 draw_slice(s, height); // just 1 large slice as this is not possible in reverse order
01161                 break;
01162             default:
01163                 av_log(avctx, AV_LOG_ERROR, "prediction type not supported!\n");
01164             }
01165         }else{
01166 
01167             av_log(avctx, AV_LOG_ERROR, "BGR24 output is not implemented yet\n");
01168             return -1;
01169         }
01170     }
01171     emms_c();
01172 
01173     *picture= *p;
01174     *data_size = sizeof(AVFrame);
01175 
01176     return (get_bits_count(&s->gb)+31)/32*4 + table_size;
01177 }
01178 #endif /* CONFIG_HUFFYUV_DECODER || CONFIG_FFVHUFF_DECODER */
01179 
01180 static int common_end(HYuvContext *s){
01181     int i;
01182 
01183     for(i=0; i<3; i++){
01184         av_freep(&s->temp[i]);
01185     }
01186     return 0;
01187 }
01188 
01189 #if CONFIG_HUFFYUV_DECODER || CONFIG_FFVHUFF_DECODER
01190 static av_cold int decode_end(AVCodecContext *avctx)
01191 {
01192     HYuvContext *s = avctx->priv_data;
01193     int i;
01194 
01195     if (s->picture.data[0])
01196         avctx->release_buffer(avctx, &s->picture);
01197 
01198     common_end(s);
01199     av_freep(&s->bitstream_buffer);
01200 
01201     for(i=0; i<6; i++){
01202         free_vlc(&s->vlc[i]);
01203     }
01204 
01205     return 0;
01206 }
01207 #endif /* CONFIG_HUFFYUV_DECODER || CONFIG_FFVHUFF_DECODER */
01208 
01209 #if CONFIG_HUFFYUV_ENCODER || CONFIG_FFVHUFF_ENCODER
01210 static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
01211     HYuvContext *s = avctx->priv_data;
01212     AVFrame *pict = data;
01213     const int width= s->width;
01214     const int width2= s->width>>1;
01215     const int height= s->height;
01216     const int fake_ystride= s->interlaced ? pict->linesize[0]*2  : pict->linesize[0];
01217     const int fake_ustride= s->interlaced ? pict->linesize[1]*2  : pict->linesize[1];
01218     const int fake_vstride= s->interlaced ? pict->linesize[2]*2  : pict->linesize[2];
01219     AVFrame * const p= &s->picture;
01220     int i, j, size=0;
01221 
01222     *p = *pict;
01223     p->pict_type= FF_I_TYPE;
01224     p->key_frame= 1;
01225 
01226     if(s->context){
01227         for(i=0; i<3; i++){
01228             generate_len_table(s->len[i], s->stats[i]);
01229             if(generate_bits_table(s->bits[i], s->len[i])<0)
01230                 return -1;
01231             size+= store_table(s, s->len[i], &buf[size]);
01232         }
01233 
01234         for(i=0; i<3; i++)
01235             for(j=0; j<256; j++)
01236                 s->stats[i][j] >>= 1;
01237     }
01238 
01239     init_put_bits(&s->pb, buf+size, buf_size-size);
01240 
01241     if(avctx->pix_fmt == PIX_FMT_YUV422P || avctx->pix_fmt == PIX_FMT_YUV420P){
01242         int lefty, leftu, leftv, y, cy;
01243 
01244         put_bits(&s->pb, 8, leftv= p->data[2][0]);
01245         put_bits(&s->pb, 8, lefty= p->data[0][1]);
01246         put_bits(&s->pb, 8, leftu= p->data[1][0]);
01247         put_bits(&s->pb, 8,        p->data[0][0]);
01248 
01249         lefty= sub_left_prediction(s, s->temp[0], p->data[0], width , 0);
01250         leftu= sub_left_prediction(s, s->temp[1], p->data[1], width2, 0);
01251         leftv= sub_left_prediction(s, s->temp[2], p->data[2], width2, 0);
01252 
01253         encode_422_bitstream(s, 2, width-2);
01254 
01255         if(s->predictor==MEDIAN){
01256             int lefttopy, lefttopu, lefttopv;
01257             cy=y=1;
01258             if(s->interlaced){
01259                 lefty= sub_left_prediction(s, s->temp[0], p->data[0]+p->linesize[0], width , lefty);
01260                 leftu= sub_left_prediction(s, s->temp[1], p->data[1]+p->linesize[1], width2, leftu);
01261                 leftv= sub_left_prediction(s, s->temp[2], p->data[2]+p->linesize[2], width2, leftv);
01262 
01263                 encode_422_bitstream(s, 0, width);
01264                 y++; cy++;
01265             }
01266 
01267             lefty= sub_left_prediction(s, s->temp[0], p->data[0]+fake_ystride, 4, lefty);
01268             leftu= sub_left_prediction(s, s->temp[1], p->data[1]+fake_ustride, 2, leftu);
01269             leftv= sub_left_prediction(s, s->temp[2], p->data[2]+fake_vstride, 2, leftv);
01270 
01271             encode_422_bitstream(s, 0, 4);
01272 
01273             lefttopy= p->data[0][3];
01274             lefttopu= p->data[1][1];
01275             lefttopv= p->data[2][1];
01276             s->dsp.sub_hfyu_median_prediction(s->temp[0], p->data[0]+4, p->data[0] + fake_ystride+4, width-4 , &lefty, &lefttopy);
01277             s->dsp.sub_hfyu_median_prediction(s->temp[1], p->data[1]+2, p->data[1] + fake_ustride+2, width2-2, &leftu, &lefttopu);
01278             s->dsp.sub_hfyu_median_prediction(s->temp[2], p->data[2]+2, p->data[2] + fake_vstride+2, width2-2, &leftv, &lefttopv);
01279             encode_422_bitstream(s, 0, width-4);
01280             y++; cy++;
01281 
01282             for(; y<height; y++,cy++){
01283                 uint8_t *ydst, *udst, *vdst;
01284 
01285                 if(s->bitstream_bpp==12){
01286                     while(2*cy > y){
01287                         ydst= p->data[0] + p->linesize[0]*y;
01288                         s->dsp.sub_hfyu_median_prediction(s->temp[0], ydst - fake_ystride, ydst, width , &lefty, &lefttopy);
01289                         encode_gray_bitstream(s, width);
01290                         y++;
01291                     }
01292                     if(y>=height) break;
01293                 }
01294                 ydst= p->data[0] + p->linesize[0]*y;
01295                 udst= p->data[1] + p->linesize[1]*cy;
01296                 vdst= p->data[2] + p->linesize[2]*cy;
01297 
01298                 s->dsp.sub_hfyu_median_prediction(s->temp[0], ydst - fake_ystride, ydst, width , &lefty, &lefttopy);
01299                 s->dsp.sub_hfyu_median_prediction(s->temp[1], udst - fake_ustride, udst, width2, &leftu, &lefttopu);
01300                 s->dsp.sub_hfyu_median_prediction(s->temp[2], vdst - fake_vstride, vdst, width2, &leftv, &lefttopv);
01301 
01302                 encode_422_bitstream(s, 0, width);
01303             }
01304         }else{
01305             for(cy=y=1; y<height; y++,cy++){
01306                 uint8_t *ydst, *udst, *vdst;
01307 
01308                 /* encode a luma only line & y++ */
01309                 if(s->bitstream_bpp==12){
01310                     ydst= p->data[0] + p->linesize[0]*y;
01311 
01312                     if(s->predictor == PLANE && s->interlaced < y){
01313                         s->dsp.diff_bytes(s->temp[1], ydst, ydst - fake_ystride, width);
01314 
01315                         lefty= sub_left_prediction(s, s->temp[0], s->temp[1], width , lefty);
01316                     }else{
01317                         lefty= sub_left_prediction(s, s->temp[0], ydst, width , lefty);
01318                     }
01319                     encode_gray_bitstream(s, width);
01320                     y++;
01321                     if(y>=height) break;
01322                 }
01323 
01324                 ydst= p->data[0] + p->linesize[0]*y;
01325                 udst= p->data[1] + p->linesize[1]*cy;
01326                 vdst= p->data[2] + p->linesize[2]*cy;
01327 
01328                 if(s->predictor == PLANE && s->interlaced < cy){
01329                     s->dsp.diff_bytes(s->temp[1], ydst, ydst - fake_ystride, width);
01330                     s->dsp.diff_bytes(s->temp[2], udst, udst - fake_ustride, width2);
01331                     s->dsp.diff_bytes(s->temp[2] + width2, vdst, vdst - fake_vstride, width2);
01332 
01333                     lefty= sub_left_prediction(s, s->temp[0], s->temp[1], width , lefty);
01334                     leftu= sub_left_prediction(s, s->temp[1], s->temp[2], width2, leftu);
01335                     leftv= sub_left_prediction(s, s->temp[2], s->temp[2] + width2, width2, leftv);
01336                 }else{
01337                     lefty= sub_left_prediction(s, s->temp[0], ydst, width , lefty);
01338                     leftu= sub_left_prediction(s, s->temp[1], udst, width2, leftu);
01339                     leftv= sub_left_prediction(s, s->temp[2], vdst, width2, leftv);
01340                 }
01341 
01342                 encode_422_bitstream(s, 0, width);
01343             }
01344         }
01345     }else if(avctx->pix_fmt == PIX_FMT_RGB32){
01346         uint8_t *data = p->data[0] + (height-1)*p->linesize[0];
01347         const int stride = -p->linesize[0];
01348         const int fake_stride = -fake_ystride;
01349         int y;
01350         int leftr, leftg, leftb;
01351 
01352         put_bits(&s->pb, 8, leftr= data[R]);
01353         put_bits(&s->pb, 8, leftg= data[G]);
01354         put_bits(&s->pb, 8, leftb= data[B]);
01355         put_bits(&s->pb, 8, 0);
01356 
01357         sub_left_prediction_bgr32(s, s->temp[0], data+4, width-1, &leftr, &leftg, &leftb);
01358         encode_bgr_bitstream(s, width-1);
01359 
01360         for(y=1; y<s->height; y++){
01361             uint8_t *dst = data + y*stride;
01362             if(s->predictor == PLANE && s->interlaced < y){
01363                 s->dsp.diff_bytes(s->temp[1], dst, dst - fake_stride, width*4);
01364                 sub_left_prediction_bgr32(s, s->temp[0], s->temp[1], width, &leftr, &leftg, &leftb);
01365             }else{
01366                 sub_left_prediction_bgr32(s, s->temp[0], dst, width, &leftr, &leftg, &leftb);
01367             }
01368             encode_bgr_bitstream(s, width);
01369         }
01370     }else{
01371         av_log(avctx, AV_LOG_ERROR, "Format not supported!\n");
01372     }
01373     emms_c();
01374 
01375     size+= (put_bits_count(&s->pb)+31)/8;
01376     put_bits(&s->pb, 16, 0);
01377     put_bits(&s->pb, 15, 0);
01378     size/= 4;
01379 
01380     if((s->flags&CODEC_FLAG_PASS1) && (s->picture_number&31)==0){
01381         int j;
01382         char *p= avctx->stats_out;
01383         char *end= p + 1024*30;
01384         for(i=0; i<3; i++){
01385             for(j=0; j<256; j++){
01386                 snprintf(p, end-p, "%"PRIu64" ", s->stats[i][j]);
01387                 p+= strlen(p);
01388                 s->stats[i][j]= 0;
01389             }
01390             snprintf(p, end-p, "\n");
01391             p++;
01392         }
01393     } else
01394         avctx->stats_out[0] = '\0';
01395     if(!(s->avctx->flags2 & CODEC_FLAG2_NO_OUTPUT)){
01396         flush_put_bits(&s->pb);
01397         s->dsp.bswap_buf((uint32_t*)buf, (uint32_t*)buf, size);
01398     }
01399 
01400     s->picture_number++;
01401 
01402     return size*4;
01403 }
01404 
01405 static av_cold int encode_end(AVCodecContext *avctx)
01406 {
01407     HYuvContext *s = avctx->priv_data;
01408 
01409     common_end(s);
01410 
01411     av_freep(&avctx->extradata);
01412     av_freep(&avctx->stats_out);
01413 
01414     return 0;
01415 }
01416 #endif /* CONFIG_HUFFYUV_ENCODER || CONFIG_FFVHUFF_ENCODER */
01417 
01418 #if CONFIG_HUFFYUV_DECODER
01419 AVCodec huffyuv_decoder = {
01420     "huffyuv",
01421     AVMEDIA_TYPE_VIDEO,
01422     CODEC_ID_HUFFYUV,
01423     sizeof(HYuvContext),
01424     decode_init,
01425     NULL,
01426     decode_end,
01427     decode_frame,
01428     CODEC_CAP_DR1 | CODEC_CAP_DRAW_HORIZ_BAND,
01429     NULL,
01430     .long_name = NULL_IF_CONFIG_SMALL("Huffyuv / HuffYUV"),
01431 };
01432 #endif
01433 
01434 #if CONFIG_FFVHUFF_DECODER
01435 AVCodec ffvhuff_decoder = {
01436     "ffvhuff",
01437     AVMEDIA_TYPE_VIDEO,
01438     CODEC_ID_FFVHUFF,
01439     sizeof(HYuvContext),
01440     decode_init,
01441     NULL,
01442     decode_end,
01443     decode_frame,
01444     CODEC_CAP_DR1 | CODEC_CAP_DRAW_HORIZ_BAND,
01445     NULL,
01446     .long_name = NULL_IF_CONFIG_SMALL("Huffyuv FFmpeg variant"),
01447 };
01448 #endif
01449 
01450 #if CONFIG_HUFFYUV_ENCODER
01451 AVCodec huffyuv_encoder = {
01452     "huffyuv",
01453     AVMEDIA_TYPE_VIDEO,
01454     CODEC_ID_HUFFYUV,
01455     sizeof(HYuvContext),
01456     encode_init,
01457     encode_frame,
01458     encode_end,
01459     .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV422P, PIX_FMT_RGB32, PIX_FMT_NONE},
01460     .long_name = NULL_IF_CONFIG_SMALL("Huffyuv / HuffYUV"),
01461 };
01462 #endif
01463 
01464 #if CONFIG_FFVHUFF_ENCODER
01465 AVCodec ffvhuff_encoder = {
01466     "ffvhuff",
01467     AVMEDIA_TYPE_VIDEO,
01468     CODEC_ID_FFVHUFF,
01469     sizeof(HYuvContext),
01470     encode_init,
01471     encode_frame,
01472     encode_end,
01473     .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_RGB32, PIX_FMT_NONE},
01474     .long_name = NULL_IF_CONFIG_SMALL("Huffyuv FFmpeg variant"),
01475 };
01476 #endif