00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
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;
00068 int bgr32;
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];
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
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
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
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)
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
00310
00311
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
00450
00451 if(avctx->extradata_size){
00452 if((avctx->bits_per_coded_sample&7) && avctx->bits_per_coded_sample != 12)
00453 s->version=1;
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;
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
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
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);
00592 avctx->stats_out= av_mallocz(1024*30);
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
00703
00704 alloc_temp(s);
00705
00706 s->picture_number=0;
00707
00708 return 0;
00709 }
00710 #endif
00711
00712
00713
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
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
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
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
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
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--){
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);
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
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
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
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
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