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

Generated on Wed Apr 11 2012 07:31:33 for FFmpeg by  doxygen 1.7.1