• Main Page
  • Related Pages
  • Modules
  • Data Structures
  • Files
  • Examples
  • File List
  • Globals

libavcodec/huffyuv.c

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