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

Generated on Fri Feb 22 2013 07:24:27 for FFmpeg by  doxygen 1.7.1