git.sesse.net Git - ffmpeg/blob - libavcodec/dv.c

   1 /*
   2  * DV decoder
   3  * Copyright (c) 2002 Fabrice Bellard.
   4  * Copyright (c) 2004 Roman Shaposhnik.
   5  *
   6  * DV encoder
   7  * Copyright (c) 2003 Roman Shaposhnik.
   8  *
   9  * 50 Mbps (DVCPRO50) support
  10  * Copyright (c) 2006 Daniel Maas <dmaas@maasdigital.com>
  11  *
  12  * Many thanks to Dan Dennedy <dan@dennedy.org> for providing wealth
  13  * of DV technical info.
  14  *
  15  * This library is free software; you can redistribute it and/or
  16  * modify it under the terms of the GNU Lesser General Public
  17  * License as published by the Free Software Foundation; either
  18  * version 2 of the License, or (at your option) any later version.
  19  *
  20  * This library is distributed in the hope that it will be useful,
  21  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  22  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  23  * Lesser General Public License for more details.
  24  *
  25  * You should have received a copy of the GNU Lesser General Public
  26  * License along with this library; if not, write to the Free Software
  27  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  28  */
  29
  30 /**
  31  * @file dv.c
  32  * DV codec.
  33  */
  34 #include "avcodec.h"
  35 #include "dsputil.h"
  36 #include "mpegvideo.h"
  37 #include "simple_idct.h"
  38 #include "dvdata.h"
  39
  40 //#undef NDEBUG
  41 //#include <assert.h>
  42
  43 typedef struct DVVideoContext {
  44     const DVprofile* sys;
  45     AVFrame picture;
  46     AVCodecContext *avctx;
  47     uint8_t *buf;
  48
  49     uint8_t dv_zigzag[2][64];
  50     uint8_t dv_idct_shift[2][2][22][64];
  51
  52     void (*get_pixels)(DCTELEM *block, const uint8_t *pixels, int line_size);
  53     void (*fdct[2])(DCTELEM *block);
  54     void (*idct_put[2])(uint8_t *dest, int line_size, DCTELEM *block);
  55 } DVVideoContext;
  56
  57 /* MultiThreading - dv_anchor applies to entire DV codec, not just the avcontext */
  58 /* one element is needed for each video segment in a DV frame */
  59 /* at most there are 2 DIF channels * 12 DIF sequences * 27 video segments (PAL 50Mbps) */
  60 #define DV_ANCHOR_SIZE (2*12*27)
  61
  62 static void* dv_anchor[DV_ANCHOR_SIZE];
  63
  64 #define TEX_VLC_BITS 9
  65
  66 #ifdef DV_CODEC_TINY_TARGET
  67 #define DV_VLC_MAP_RUN_SIZE 15
  68 #define DV_VLC_MAP_LEV_SIZE 23
  69 #else
  70 #define DV_VLC_MAP_RUN_SIZE  64
  71 #define DV_VLC_MAP_LEV_SIZE 512 //FIXME sign was removed so this should be /2 but needs check
  72 #endif
  73
  74 /* XXX: also include quantization */
  75 static RL_VLC_ELEM *dv_rl_vlc;
  76 /* VLC encoding lookup table */
  77 static struct dv_vlc_pair {
  78    uint32_t vlc;
  79    uint8_t  size;
  80 } (*dv_vlc_map)[DV_VLC_MAP_LEV_SIZE] = NULL;
  81
  82 static void dv_build_unquantize_tables(DVVideoContext *s, uint8_t* perm)
  83 {
  84     int i, q, j;
  85
  86     /* NOTE: max left shift is 6 */
  87     for(q = 0; q < 22; q++) {
  88         /* 88DCT */
  89         for(i = 1; i < 64; i++) {
  90             /* 88 table */
  91             j = perm[i];
  92             s->dv_idct_shift[0][0][q][j] =
  93                 dv_quant_shifts[q][dv_88_areas[i]] + 1;
  94             s->dv_idct_shift[1][0][q][j] = s->dv_idct_shift[0][0][q][j] + 1;
  95         }
  96
  97         /* 248DCT */
  98         for(i = 1; i < 64; i++) {
  99             /* 248 table */
 100             s->dv_idct_shift[0][1][q][i] =
 101                 dv_quant_shifts[q][dv_248_areas[i]] + 1;
 102             s->dv_idct_shift[1][1][q][i] = s->dv_idct_shift[0][1][q][i] + 1;
 103         }
 104     }
 105 }
 106
 107 static int dvvideo_init(AVCodecContext *avctx)
 108 {
 109     DVVideoContext *s = avctx->priv_data;
 110     DSPContext dsp;
 111     static int done=0;
 112     int i, j;
 113
 114     if (!done) {
 115         VLC dv_vlc;
 116         uint16_t new_dv_vlc_bits[NB_DV_VLC*2];
 117         uint8_t new_dv_vlc_len[NB_DV_VLC*2];
 118         uint8_t new_dv_vlc_run[NB_DV_VLC*2];
 119         int16_t new_dv_vlc_level[NB_DV_VLC*2];
 120
 121         done = 1;
 122
 123         dv_vlc_map = av_mallocz_static(DV_VLC_MAP_LEV_SIZE*DV_VLC_MAP_RUN_SIZE*sizeof(struct dv_vlc_pair));
 124         if (!dv_vlc_map)
 125             return -ENOMEM;
 126
 127         /* dv_anchor lets each thread know its Id */
 128         for (i=0; i<DV_ANCHOR_SIZE; i++)
 129             dv_anchor[i] = (void*)(size_t)i;
 130
 131         /* it's faster to include sign bit in a generic VLC parsing scheme */
 132         for (i=0, j=0; i<NB_DV_VLC; i++, j++) {
 133             new_dv_vlc_bits[j] = dv_vlc_bits[i];
 134             new_dv_vlc_len[j] = dv_vlc_len[i];
 135             new_dv_vlc_run[j] = dv_vlc_run[i];
 136             new_dv_vlc_level[j] = dv_vlc_level[i];
 137
 138             if (dv_vlc_level[i]) {
 139                 new_dv_vlc_bits[j] <<= 1;
 140                 new_dv_vlc_len[j]++;
 141
 142                 j++;
 143                 new_dv_vlc_bits[j] = (dv_vlc_bits[i] << 1) | 1;
 144                 new_dv_vlc_len[j] = dv_vlc_len[i] + 1;
 145                 new_dv_vlc_run[j] = dv_vlc_run[i];
 146                 new_dv_vlc_level[j] = -dv_vlc_level[i];
 147             }
 148         }
 149
 150         /* NOTE: as a trick, we use the fact the no codes are unused
 151            to accelerate the parsing of partial codes */
 152         init_vlc(&dv_vlc, TEX_VLC_BITS, j,
 153                  new_dv_vlc_len, 1, 1, new_dv_vlc_bits, 2, 2, 0);
 154
 155         dv_rl_vlc = av_mallocz_static(dv_vlc.table_size * sizeof(RL_VLC_ELEM));
 156         if (!dv_rl_vlc)
 157             return -ENOMEM;
 158
 159         for(i = 0; i < dv_vlc.table_size; i++){
 160             int code= dv_vlc.table[i][0];
 161             int len = dv_vlc.table[i][1];
 162             int level, run;
 163
 164             if(len<0){ //more bits needed
 165                 run= 0;
 166                 level= code;
 167             } else {
 168                 run=   new_dv_vlc_run[code] + 1;
 169                 level= new_dv_vlc_level[code];
 170             }
 171             dv_rl_vlc[i].len = len;
 172             dv_rl_vlc[i].level = level;
 173             dv_rl_vlc[i].run = run;
 174         }
 175         free_vlc(&dv_vlc);
 176
 177         for (i = 0; i < NB_DV_VLC - 1; i++) {
 178            if (dv_vlc_run[i] >= DV_VLC_MAP_RUN_SIZE)
 179                continue;
 180 #ifdef DV_CODEC_TINY_TARGET
 181            if (dv_vlc_level[i] >= DV_VLC_MAP_LEV_SIZE)
 182                continue;
 183 #endif
 184
 185            if (dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].size != 0)
 186                continue;
 187
 188            dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].vlc = dv_vlc_bits[i] <<
 189                                                             (!!dv_vlc_level[i]);
 190            dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].size = dv_vlc_len[i] +
 191                                                              (!!dv_vlc_level[i]);
 192         }
 193         for (i = 0; i < DV_VLC_MAP_RUN_SIZE; i++) {
 194 #ifdef DV_CODEC_TINY_TARGET
 195            for (j = 1; j < DV_VLC_MAP_LEV_SIZE; j++) {
 196               if (dv_vlc_map[i][j].size == 0) {
 197                   dv_vlc_map[i][j].vlc = dv_vlc_map[0][j].vlc |
 198                             (dv_vlc_map[i-1][0].vlc << (dv_vlc_map[0][j].size));
 199                   dv_vlc_map[i][j].size = dv_vlc_map[i-1][0].size +
 200                                           dv_vlc_map[0][j].size;
 201               }
 202            }
 203 #else
 204            for (j = 1; j < DV_VLC_MAP_LEV_SIZE/2; j++) {
 205               if (dv_vlc_map[i][j].size == 0) {
 206                   dv_vlc_map[i][j].vlc = dv_vlc_map[0][j].vlc |
 207                             (dv_vlc_map[i-1][0].vlc << (dv_vlc_map[0][j].size));
 208                   dv_vlc_map[i][j].size = dv_vlc_map[i-1][0].size +
 209                                           dv_vlc_map[0][j].size;
 210               }
 211               dv_vlc_map[i][((uint16_t)(-j))&0x1ff].vlc =
 212                                             dv_vlc_map[i][j].vlc | 1;
 213               dv_vlc_map[i][((uint16_t)(-j))&0x1ff].size =
 214                                             dv_vlc_map[i][j].size;
 215            }
 216 #endif
 217         }
 218     }
 219
 220     /* Generic DSP setup */
 221     dsputil_init(&dsp, avctx);
 222     s->get_pixels = dsp.get_pixels;
 223
 224     /* 88DCT setup */
 225     s->fdct[0] = dsp.fdct;
 226     s->idct_put[0] = dsp.idct_put;
 227     for (i=0; i<64; i++)
 228        s->dv_zigzag[0][i] = dsp.idct_permutation[ff_zigzag_direct[i]];
 229
 230     /* 248DCT setup */
 231     s->fdct[1] = dsp.fdct248;
 232     s->idct_put[1] = simple_idct248_put;  // FIXME: need to add it to DSP
 233     if(avctx->lowres){
 234         for (i=0; i<64; i++){
 235             int j= ff_zigzag248_direct[i];
 236             s->dv_zigzag[1][i] = dsp.idct_permutation[(j&7) + (j&8)*4 + (j&48)/2];
 237         }
 238     }else
 239         memcpy(s->dv_zigzag[1], ff_zigzag248_direct, 64);
 240
 241     /* XXX: do it only for constant case */
 242     dv_build_unquantize_tables(s, dsp.idct_permutation);
 243
 244     avctx->coded_frame = &s->picture;
 245     s->avctx= avctx;
 246
 247     return 0;
 248 }
 249
 250 // #define VLC_DEBUG
 251 // #define printf(...) av_log(NULL, AV_LOG_ERROR, __VA_ARGS__)
 252
 253 typedef struct BlockInfo {
 254     const uint8_t *shift_table;
 255     const uint8_t *scan_table;
 256     const int *iweight_table;
 257     uint8_t pos; /* position in block */
 258     uint8_t dct_mode;
 259     uint8_t partial_bit_count;
 260     uint16_t partial_bit_buffer;
 261     int shift_offset;
 262 } BlockInfo;
 263
 264 /* block size in bits */
 265 static const uint16_t block_sizes[6] = {
 266     112, 112, 112, 112, 80, 80
 267 };
 268 /* bit budget for AC only in 5 MBs */
 269 static const int vs_total_ac_bits = (100 * 4 + 68*2) * 5;
 270 /* see dv_88_areas and dv_248_areas for details */
 271 static const int mb_area_start[5] = { 1, 6, 21, 43, 64 };
 272
 273 #ifndef ALT_BITSTREAM_READER
 274 #warning only works with ALT_BITSTREAM_READER
 275 static int re_index; //Hack to make it compile
 276 #endif
 277
 278 static inline int get_bits_left(GetBitContext *s)
 279 {
 280     return s->size_in_bits - get_bits_count(s);
 281 }
 282
 283 static inline int get_bits_size(GetBitContext *s)
 284 {
 285     return s->size_in_bits;
 286 }
 287
 288 static inline int put_bits_left(PutBitContext* s)
 289 {
 290     return (s->buf_end - s->buf) * 8 - put_bits_count(s);
 291 }
 292
 293 /* decode ac coefs */
 294 static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, DCTELEM *block)
 295 {
 296     int last_index = get_bits_size(gb);
 297     const uint8_t *scan_table = mb->scan_table;
 298     const uint8_t *shift_table = mb->shift_table;
 299     const int *iweight_table = mb->iweight_table;
 300     int pos = mb->pos;
 301     int partial_bit_count = mb->partial_bit_count;
 302     int level, pos1, run, vlc_len, index;
 303
 304     OPEN_READER(re, gb);
 305     UPDATE_CACHE(re, gb);
 306
 307     /* if we must parse a partial vlc, we do it here */
 308     if (partial_bit_count > 0) {
 309         re_cache = ((unsigned)re_cache >> partial_bit_count) |
 310                    (mb->partial_bit_buffer << (sizeof(re_cache)*8 - partial_bit_count));
 311         re_index -= partial_bit_count;
 312         mb->partial_bit_count = 0;
 313     }
 314
 315     /* get the AC coefficients until last_index is reached */
 316     for(;;) {
 317 #ifdef VLC_DEBUG
 318         printf("%2d: bits=%04x index=%d\n", pos, SHOW_UBITS(re, gb, 16), re_index);
 319 #endif
 320         /* our own optimized GET_RL_VLC */
 321         index = NEG_USR32(re_cache, TEX_VLC_BITS);
 322         vlc_len = dv_rl_vlc[index].len;
 323         if (vlc_len < 0) {
 324             index = NEG_USR32((unsigned)re_cache << TEX_VLC_BITS, -vlc_len) + dv_rl_vlc[index].level;
 325             vlc_len = TEX_VLC_BITS - vlc_len;
 326         }
 327         level = dv_rl_vlc[index].level;
 328         run = dv_rl_vlc[index].run;
 329
 330         /* gotta check if we're still within gb boundaries */
 331         if (re_index + vlc_len > last_index) {
 332             /* should be < 16 bits otherwise a codeword could have been parsed */
 333             mb->partial_bit_count = last_index - re_index;
 334             mb->partial_bit_buffer = NEG_USR32(re_cache, mb->partial_bit_count);
 335             re_index = last_index;
 336             break;
 337         }
 338         re_index += vlc_len;
 339
 340 #ifdef VLC_DEBUG
 341         printf("run=%d level=%d\n", run, level);
 342 #endif
 343         pos += run;
 344         if (pos >= 64)
 345             break;
 346
 347         pos1 = scan_table[pos];
 348         level <<= shift_table[pos1];
 349
 350         /* unweigh, round, and shift down */
 351         level = (level*iweight_table[pos] + (1 << (dv_iweight_bits-1))) >> dv_iweight_bits;
 352
 353         block[pos1] = level;
 354
 355         UPDATE_CACHE(re, gb);
 356     }
 357     CLOSE_READER(re, gb);
 358     mb->pos = pos;
 359 }
 360
 361 static inline void bit_copy(PutBitContext *pb, GetBitContext *gb)
 362 {
 363     int bits_left = get_bits_left(gb);
 364     while (bits_left >= MIN_CACHE_BITS) {
 365         put_bits(pb, MIN_CACHE_BITS, get_bits(gb, MIN_CACHE_BITS));
 366         bits_left -= MIN_CACHE_BITS;
 367     }
 368     if (bits_left > 0) {
 369         put_bits(pb, bits_left, get_bits(gb, bits_left));
 370     }
 371 }
 372
 373 /* mb_x and mb_y are in units of 8 pixels */
 374 static inline void dv_decode_video_segment(DVVideoContext *s,
 375                                            uint8_t *buf_ptr1,
 376                                            const uint16_t *mb_pos_ptr)
 377 {
 378     int quant, dc, dct_mode, class1, j;
 379     int mb_index, mb_x, mb_y, v, last_index;
 380     DCTELEM *block, *block1;
 381     int c_offset;
 382     uint8_t *y_ptr;
 383     void (*idct_put)(uint8_t *dest, int line_size, DCTELEM *block);
 384     uint8_t *buf_ptr;
 385     PutBitContext pb, vs_pb;
 386     GetBitContext gb;
 387     BlockInfo mb_data[5 * 6], *mb, *mb1;
 388     DECLARE_ALIGNED_8(DCTELEM, sblock[5*6][64]);
 389     DECLARE_ALIGNED_8(uint8_t, mb_bit_buffer[80 + 4]); /* allow some slack */
 390     DECLARE_ALIGNED_8(uint8_t, vs_bit_buffer[5 * 80 + 4]); /* allow some slack */
 391     const int log2_blocksize= 3-s->avctx->lowres;
 392
 393     assert((((int)mb_bit_buffer)&7)==0);
 394     assert((((int)vs_bit_buffer)&7)==0);
 395
 396     memset(sblock, 0, sizeof(sblock));
 397
 398     /* pass 1 : read DC and AC coefficients in blocks */
 399     buf_ptr = buf_ptr1;
 400     block1 = &sblock[0][0];
 401     mb1 = mb_data;
 402     init_put_bits(&vs_pb, vs_bit_buffer, 5 * 80);
 403     for(mb_index = 0; mb_index < 5; mb_index++, mb1 += 6, block1 += 6 * 64) {
 404         /* skip header */
 405         quant = buf_ptr[3] & 0x0f;
 406         buf_ptr += 4;
 407         init_put_bits(&pb, mb_bit_buffer, 80);
 408         mb = mb1;
 409         block = block1;
 410         for(j = 0;j < 6; j++) {
 411             last_index = block_sizes[j];
 412             init_get_bits(&gb, buf_ptr, last_index);
 413
 414             /* get the dc */
 415             dc = get_sbits(&gb, 9);
 416             dct_mode = get_bits1(&gb);
 417             mb->dct_mode = dct_mode;
 418             mb->scan_table = s->dv_zigzag[dct_mode];
 419             mb->iweight_table = dct_mode ? dv_iweight_248 : dv_iweight_88;
 420             class1 = get_bits(&gb, 2);
 421             mb->shift_table = s->dv_idct_shift[class1 == 3][dct_mode]
 422                 [quant + dv_quant_offset[class1]];
 423             dc = dc << 2;
 424             /* convert to unsigned because 128 is not added in the
 425                standard IDCT */
 426             dc += 1024;
 427             block[0] = dc;
 428             buf_ptr += last_index >> 3;
 429             mb->pos = 0;
 430             mb->partial_bit_count = 0;
 431
 432 #ifdef VLC_DEBUG
 433             printf("MB block: %d, %d ", mb_index, j);
 434 #endif
 435             dv_decode_ac(&gb, mb, block);
 436
 437             /* write the remaining bits  in a new buffer only if the
 438                block is finished */
 439             if (mb->pos >= 64)
 440                 bit_copy(&pb, &gb);
 441
 442             block += 64;
 443             mb++;
 444         }
 445
 446         /* pass 2 : we can do it just after */
 447 #ifdef VLC_DEBUG
 448         printf("***pass 2 size=%d MB#=%d\n", put_bits_count(&pb), mb_index);
 449 #endif
 450         block = block1;
 451         mb = mb1;
 452         init_get_bits(&gb, mb_bit_buffer, put_bits_count(&pb));
 453         flush_put_bits(&pb);
 454         for(j = 0;j < 6; j++, block += 64, mb++) {
 455             if (mb->pos < 64 && get_bits_left(&gb) > 0) {
 456                 dv_decode_ac(&gb, mb, block);
 457                 /* if still not finished, no need to parse other blocks */
 458                 if (mb->pos < 64)
 459                     break;
 460             }
 461         }
 462         /* all blocks are finished, so the extra bytes can be used at
 463            the video segment level */
 464         if (j >= 6)
 465             bit_copy(&vs_pb, &gb);
 466     }
 467
 468     /* we need a pass other the whole video segment */
 469 #ifdef VLC_DEBUG
 470     printf("***pass 3 size=%d\n", put_bits_count(&vs_pb));
 471 #endif
 472     block = &sblock[0][0];
 473     mb = mb_data;
 474     init_get_bits(&gb, vs_bit_buffer, put_bits_count(&vs_pb));
 475     flush_put_bits(&vs_pb);
 476     for(mb_index = 0; mb_index < 5; mb_index++) {
 477         for(j = 0;j < 6; j++) {
 478             if (mb->pos < 64) {
 479 #ifdef VLC_DEBUG
 480                 printf("start %d:%d\n", mb_index, j);
 481 #endif
 482                 dv_decode_ac(&gb, mb, block);
 483             }
 484             if (mb->pos >= 64 && mb->pos < 127)
 485                 av_log(NULL, AV_LOG_ERROR, "AC EOB marker is absent pos=%d\n", mb->pos);
 486             block += 64;
 487             mb++;
 488         }
 489     }
 490
 491     /* compute idct and place blocks */
 492     block = &sblock[0][0];
 493     mb = mb_data;
 494     for(mb_index = 0; mb_index < 5; mb_index++) {
 495         v = *mb_pos_ptr++;
 496         mb_x = v & 0xff;
 497         mb_y = v >> 8;
 498         if (s->sys->pix_fmt == PIX_FMT_YUV422P) {
 499             y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + (mb_x>>1))<<log2_blocksize);
 500             c_offset = ((mb_y * s->picture.linesize[1] + (mb_x >> 2))<<log2_blocksize);
 501         } else { /* 4:1:1 or 4:2:0 */
 502             y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x)<<log2_blocksize);
 503             if (s->sys->pix_fmt == PIX_FMT_YUV411P)
 504                 c_offset = ((mb_y * s->picture.linesize[1] + (mb_x >> 2))<<log2_blocksize);
 505             else /* 4:2:0 */
 506                 c_offset = (((mb_y >> 1) * s->picture.linesize[1] + (mb_x >> 1))<<log2_blocksize);
 507         }
 508         for(j = 0;j < 6; j++) {
 509             idct_put = s->idct_put[mb->dct_mode && log2_blocksize==3];
 510             if (s->sys->pix_fmt == PIX_FMT_YUV422P) { /* 4:2:2 */
 511                 if (j == 0 || j == 2) {
 512                     /* Y0 Y1 */
 513                     idct_put(y_ptr + ((j >> 1)<<log2_blocksize),
 514                              s->picture.linesize[0], block);
 515                 } else if(j > 3) {
 516                     /* Cr Cb */
 517                     idct_put(s->picture.data[6 - j] + c_offset,
 518                              s->picture.linesize[6 - j], block);
 519                 }
 520                 /* note: j=1 and j=3 are "dummy" blocks in 4:2:2 */
 521             } else { /* 4:1:1 or 4:2:0 */
 522                 if (j < 4) {
 523                     if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x < (704 / 8)) {
 524                         /* NOTE: at end of line, the macroblock is handled as 420 */
 525                         idct_put(y_ptr + (j<<log2_blocksize), s->picture.linesize[0], block);
 526                     } else {
 527                         idct_put(y_ptr + (((j & 1) + (j >> 1) * s->picture.linesize[0])<<log2_blocksize),
 528                                  s->picture.linesize[0], block);
 529                     }
 530                 } else {
 531                     if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
 532                         uint64_t aligned_pixels[64/8];
 533                         uint8_t *pixels= (uint8_t*)aligned_pixels;
 534                         uint8_t *c_ptr, *c_ptr1, *ptr, *ptr1;
 535                         int x, y, linesize;
 536                         /* NOTE: at end of line, the macroblock is handled as 420 */
 537                         idct_put(pixels, 8, block);
 538                         linesize = s->picture.linesize[6 - j];
 539                         c_ptr = s->picture.data[6 - j] + c_offset;
 540                         ptr = pixels;
 541                         for(y = 0;y < (1<<log2_blocksize); y++) {
 542                             ptr1= ptr + (1<<(log2_blocksize-1));
 543                             c_ptr1 = c_ptr + (linesize<<log2_blocksize);
 544                             for(x=0; x < (1<<(log2_blocksize-1)); x++){
 545                                 c_ptr[x]= ptr[x]; c_ptr1[x]= ptr1[x];
 546                             }
 547                             c_ptr += linesize;
 548                             ptr += 8;
 549                         }
 550                     } else {
 551                         /* don't ask me why they inverted Cb and Cr ! */
 552                         idct_put(s->picture.data[6 - j] + c_offset,
 553                                  s->picture.linesize[6 - j], block);
 554                     }
 555                 }
 556             }
 557             block += 64;
 558             mb++;
 559         }
 560     }
 561 }
 562
 563 #ifdef DV_CODEC_TINY_TARGET
 564 /* Converts run and level (where level != 0) pair into vlc, returning bit size */
 565 static always_inline int dv_rl2vlc(int run, int level, int sign, uint32_t* vlc)
 566 {
 567     int size;
 568     if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
 569         *vlc = dv_vlc_map[run][level].vlc | sign;
 570         size = dv_vlc_map[run][level].size;
 571     }
 572     else {
 573         if (level < DV_VLC_MAP_LEV_SIZE) {
 574             *vlc = dv_vlc_map[0][level].vlc | sign;
 575             size = dv_vlc_map[0][level].size;
 576         } else {
 577             *vlc = 0xfe00 | (level << 1) | sign;
 578             size = 16;
 579         }
 580         if (run) {
 581             *vlc |= ((run < 16) ? dv_vlc_map[run-1][0].vlc :
 582                                   (0x1f80 | (run - 1))) << size;
 583             size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
 584         }
 585     }
 586
 587     return size;
 588 }
 589
 590 static always_inline int dv_rl2vlc_size(int run, int level)
 591 {
 592     int size;
 593
 594     if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
 595         size = dv_vlc_map[run][level].size;
 596     }
 597     else {
 598         size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16;
 599         if (run) {
 600             size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
 601         }
 602     }
 603     return size;
 604 }
 605 #else
 606 static always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t* vlc)
 607 {
 608     *vlc = dv_vlc_map[run][l].vlc | sign;
 609     return dv_vlc_map[run][l].size;
 610 }
 611
 612 static always_inline int dv_rl2vlc_size(int run, int l)
 613 {
 614     return dv_vlc_map[run][l].size;
 615 }
 616 #endif
 617
 618 typedef struct EncBlockInfo {
 619     int area_q[4];
 620     int bit_size[4];
 621     int prev[5];
 622     int cur_ac;
 623     int cno;
 624     int dct_mode;
 625     DCTELEM mb[64];
 626     uint8_t next[64];
 627     uint8_t sign[64];
 628     uint8_t partial_bit_count;
 629     uint32_t partial_bit_buffer; /* we can't use uint16_t here */
 630 } EncBlockInfo;
 631
 632 static always_inline PutBitContext* dv_encode_ac(EncBlockInfo* bi, PutBitContext* pb_pool,
 633                                        PutBitContext* pb_end)
 634 {
 635     int prev;
 636     int bits_left;
 637     PutBitContext* pb = pb_pool;
 638     int size = bi->partial_bit_count;
 639     uint32_t vlc = bi->partial_bit_buffer;
 640
 641     bi->partial_bit_count = bi->partial_bit_buffer = 0;
 642     for(;;){
 643        /* Find suitable storage space */
 644        for (; size > (bits_left = put_bits_left(pb)); pb++) {
 645           if (bits_left) {
 646               size -= bits_left;
 647               put_bits(pb, bits_left, vlc >> size);
 648               vlc = vlc & ((1<<size)-1);
 649           }
 650           if (pb + 1 >= pb_end) {
 651               bi->partial_bit_count = size;
 652               bi->partial_bit_buffer = vlc;
 653               return pb;
 654           }
 655        }
 656
 657        /* Store VLC */
 658        put_bits(pb, size, vlc);
 659
 660        if(bi->cur_ac>=64)
 661            break;
 662
 663        /* Construct the next VLC */
 664        prev= bi->cur_ac;
 665        bi->cur_ac = bi->next[prev];
 666        if(bi->cur_ac < 64){
 667            size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac], bi->sign[bi->cur_ac], &vlc);
 668        } else {
 669            size = 4; vlc = 6; /* End Of Block stamp */
 670        }
 671     }
 672     return pb;
 673 }
 674
 675 static always_inline void dv_set_class_number(DCTELEM* blk, EncBlockInfo* bi,
 676                                               const uint8_t* zigzag_scan, const int *weight, int bias)
 677 {
 678     int i, area;
 679     /* We offer two different methods for class number assignment: the
 680        method suggested in SMPTE 314M Table 22, and an improved
 681        method. The SMPTE method is very conservative; it assigns class
 682        3 (i.e. severe quantization) to any block where the largest AC
 683        component is greater than 36. ffmpeg's DV encoder tracks AC bit
 684        consumption precisely, so there is no need to bias most blocks
 685        towards strongly lossy compression. Instead, we assign class 2
 686        to most blocks, and use class 3 only when strictly necessary
 687        (for blocks whose largest AC component exceeds 255). */
 688
 689 #if 0 /* SMPTE spec method */
 690     static const int classes[] = {12, 24, 36, 0xffff};
 691 #else /* improved ffmpeg method */
 692     static const int classes[] = {-1, -1, 255, 0xffff};
 693 #endif
 694     int max=classes[0];
 695     int prev=0;
 696
 697     bi->mb[0] = blk[0];
 698
 699     for (area = 0; area < 4; area++) {
 700        bi->prev[area] = prev;
 701        bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
 702        for (i=mb_area_start[area]; i<mb_area_start[area+1]; i++) {
 703           int level = blk[zigzag_scan[i]];
 704
 705           if (level+15 > 30U) {
 706               bi->sign[i] = (level>>31)&1;
 707               /* weigh it and and shift down into range, adding for rounding */
 708               /* the extra division by a factor of 2^4 reverses the 8x expansion of the DCT
 709                  AND the 2x doubling of the weights */
 710               level = (ABS(level) * weight[i] + (1<<(dv_weight_bits+3))) >> (dv_weight_bits+4);
 711               bi->mb[i] = level;
 712               if(level>max) max= level;
 713               bi->bit_size[area] += dv_rl2vlc_size(i - prev  - 1, level);
 714               bi->next[prev]= i;
 715               prev= i;
 716           }
 717        }
 718     }
 719     bi->next[prev]= i;
 720     for(bi->cno = 0; max > classes[bi->cno]; bi->cno++);
 721
 722     bi->cno += bias;
 723
 724     if (bi->cno >= 3) {
 725         bi->cno = 3;
 726         prev=0;
 727         i= bi->next[prev];
 728         for (area = 0; area < 4; area++) {
 729             bi->prev[area] = prev;
 730             bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
 731             for (; i<mb_area_start[area+1]; i= bi->next[i]) {
 732                 bi->mb[i] >>=1;
 733
 734                 if (bi->mb[i]) {
 735                     bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]);
 736                     bi->next[prev]= i;
 737                     prev= i;
 738                 }
 739             }
 740         }
 741         bi->next[prev]= i;
 742     }
 743 }
 744
 745 //FIXME replace this by dsputil
 746 #define SC(x, y) ((s[x] - s[y]) ^ ((s[x] - s[y]) >> 7))
 747 static always_inline int dv_guess_dct_mode(DCTELEM *blk) {
 748     DCTELEM *s;
 749     int score88 = 0;
 750     int score248 = 0;
 751     int i;
 752
 753     /* Compute 8-8 score (small values give a better chance for 8-8 DCT) */
 754     s = blk;
 755     for(i=0; i<7; i++) {
 756         score88 += SC(0,  8) + SC(1, 9) + SC(2, 10) + SC(3, 11) +
 757                    SC(4, 12) + SC(5,13) + SC(6, 14) + SC(7, 15);
 758         s += 8;
 759     }
 760     /* Compute 2-4-8 score (small values give a better chance for 2-4-8 DCT) */
 761     s = blk;
 762     for(i=0; i<6; i++) {
 763         score248 += SC(0, 16) + SC(1,17) + SC(2, 18) + SC(3, 19) +
 764                     SC(4, 20) + SC(5,21) + SC(6, 22) + SC(7, 23);
 765         s += 8;
 766     }
 767
 768     return (score88 - score248 > -10);
 769 }
 770
 771 static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos)
 772 {
 773     int size[5];
 774     int i, j, k, a, prev, a2;
 775     EncBlockInfo* b;
 776
 777     size[0] = size[1] = size[2] = size[3] = size[4] = 1<<24;
 778     do {
 779        b = blks;
 780        for (i=0; i<5; i++) {
 781           if (!qnos[i])
 782               continue;
 783
 784           qnos[i]--;
 785           size[i] = 0;
 786           for (j=0; j<6; j++, b++) {
 787              for (a=0; a<4; a++) {
 788                 if (b->area_q[a] != dv_quant_shifts[qnos[i] + dv_quant_offset[b->cno]][a]) {
 789                     b->bit_size[a] = 1; // 4 areas 4 bits for EOB :)
 790                     b->area_q[a]++;
 791                     prev= b->prev[a];
 792                     assert(b->next[prev] >= mb_area_start[a+1] || b->mb[prev]);
 793                     for (k= b->next[prev] ; k<mb_area_start[a+1]; k= b->next[k]) {
 794                        b->mb[k] >>= 1;
 795                        if (b->mb[k]) {
 796                            b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
 797                            prev= k;
 798                        } else {
 799                            if(b->next[k] >= mb_area_start[a+1] && b->next[k]<64){
 800                                 for(a2=a+1; b->next[k] >= mb_area_start[a2+1]; a2++)
 801                                     b->prev[a2] = prev;
 802                                 assert(a2<4);
 803                                 assert(b->mb[b->next[k]]);
 804                                 b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]])
 805                                                   -dv_rl2vlc_size(b->next[k] -    k - 1, b->mb[b->next[k]]);
 806                                 assert(b->prev[a2]==k && (a2+1 >= 4 || b->prev[a2+1]!=k));
 807                                 b->prev[a2] = prev;
 808                            }
 809                            b->next[prev] = b->next[k];
 810                        }
 811                     }
 812                     b->prev[a+1]= prev;
 813                 }
 814                 size[i] += b->bit_size[a];
 815              }
 816           }
 817           if(vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4])
 818                 return;
 819        }
 820     } while (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4]);
 821
 822
 823     for(a=2; a==2 || vs_total_ac_bits < size[0]; a+=a){
 824         b = blks;
 825         size[0] = 5*6*4; //EOB
 826         for (j=0; j<6*5; j++, b++) {
 827             prev= b->prev[0];
 828             for (k= b->next[prev]; k<64; k= b->next[k]) {
 829                 if(b->mb[k] < a && b->mb[k] > -a){
 830                     b->next[prev] = b->next[k];
 831                 }else{
 832                     size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
 833                     prev= k;
 834                 }
 835             }
 836         }
 837     }
 838 }
 839
 840 static inline void dv_encode_video_segment(DVVideoContext *s,
 841                                            uint8_t *dif,
 842                                            const uint16_t *mb_pos_ptr)
 843 {
 844     int mb_index, i, j, v;
 845     int mb_x, mb_y, c_offset, linesize;
 846     uint8_t*  y_ptr;
 847     uint8_t*  data;
 848     uint8_t*  ptr;
 849     int       do_edge_wrap;
 850     DECLARE_ALIGNED_8(DCTELEM, block[64]);
 851     EncBlockInfo  enc_blks[5*6];
 852     PutBitContext pbs[5*6];
 853     PutBitContext* pb;
 854     EncBlockInfo* enc_blk;
 855     int       vs_bit_size = 0;
 856     int       qnos[5];
 857
 858     assert((((int)block) & 7) == 0);
 859
 860     enc_blk = &enc_blks[0];
 861     pb = &pbs[0];
 862     for(mb_index = 0; mb_index < 5; mb_index++) {
 863         v = *mb_pos_ptr++;
 864         mb_x = v & 0xff;
 865         mb_y = v >> 8;
 866         if (s->sys->pix_fmt == PIX_FMT_YUV422P) {
 867             y_ptr = s->picture.data[0] + (mb_y * s->picture.linesize[0] * 8) + (mb_x * 4);
 868         } else { /* 4:1:1 */
 869             y_ptr = s->picture.data[0] + (mb_y * s->picture.linesize[0] * 8) + (mb_x * 8);
 870         }
 871         if (s->sys->pix_fmt == PIX_FMT_YUV420P) {
 872             c_offset = (((mb_y >> 1) * s->picture.linesize[1] * 8) + ((mb_x >> 1) * 8));
 873         } else { /* 4:2:2 or 4:1:1 */
 874             c_offset = ((mb_y * s->picture.linesize[1] * 8) + ((mb_x >> 2) * 8));
 875         }
 876         do_edge_wrap = 0;
 877         qnos[mb_index] = 15; /* No quantization */
 878         ptr = dif + mb_index*80 + 4;
 879         for(j = 0;j < 6; j++) {
 880             int dummy = 0;
 881             if (s->sys->pix_fmt == PIX_FMT_YUV422P) { /* 4:2:2 */
 882                 if (j == 0 || j == 2) {
 883                     /* Y0 Y1 */
 884                     data = y_ptr + ((j>>1) * 8);
 885                     linesize = s->picture.linesize[0];
 886                 } else if (j > 3) {
 887                     /* Cr Cb */
 888                     data = s->picture.data[6 - j] + c_offset;
 889                     linesize = s->picture.linesize[6 - j];
 890                 } else {
 891                     /* j=1 and j=3 are "dummy" blocks, used for AC data only */
 892                     data = 0;
 893                     linesize = 0;
 894                     dummy = 1;
 895                 }
 896             } else { /* 4:1:1 or 4:2:0 */
 897                 if (j < 4) {  /* Four Y blocks */
 898                     /* NOTE: at end of line, the macroblock is handled as 420 */
 899                     if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x < (704 / 8)) {
 900                         data = y_ptr + (j * 8);
 901                     } else {
 902                         data = y_ptr + ((j & 1) * 8) + ((j >> 1) * 8 * s->picture.linesize[0]);
 903                     }
 904                     linesize = s->picture.linesize[0];
 905                 } else {      /* Cr and Cb blocks */
 906                     /* don't ask Fabrice why they inverted Cb and Cr ! */
 907                     data = s->picture.data[6 - j] + c_offset;
 908                     linesize = s->picture.linesize[6 - j];
 909                     if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8))
 910                         do_edge_wrap = 1;
 911                 }
 912             }
 913
 914             /* Everything is set up -- now just copy data -> DCT block */
 915             if (do_edge_wrap) {  /* Edge wrap copy: 4x16 -> 8x8 */
 916                 uint8_t* d;
 917                 DCTELEM *b = block;
 918                 for (i=0;i<8;i++) {
 919                    d = data + 8 * linesize;
 920                    b[0] = data[0]; b[1] = data[1]; b[2] = data[2]; b[3] = data[3];
 921                    b[4] =    d[0]; b[5] =    d[1]; b[6] =    d[2]; b[7] =    d[3];
 922                    data += linesize;
 923                    b += 8;
 924                 }
 925             } else {             /* Simple copy: 8x8 -> 8x8 */
 926                 if (!dummy)
 927                     s->get_pixels(block, data, linesize);
 928             }
 929
 930             if(s->avctx->flags & CODEC_FLAG_INTERLACED_DCT)
 931                 enc_blk->dct_mode = dv_guess_dct_mode(block);
 932             else
 933                 enc_blk->dct_mode = 0;
 934             enc_blk->area_q[0] = enc_blk->area_q[1] = enc_blk->area_q[2] = enc_blk->area_q[3] = 0;
 935             enc_blk->partial_bit_count = 0;
 936             enc_blk->partial_bit_buffer = 0;
 937             enc_blk->cur_ac = 0;
 938
 939             if (dummy) {
 940                 /* We rely on the fact that encoding all zeros leads to an immediate EOB,
 941                    which is precisely what the spec calls for in the "dummy" blocks. */
 942                 memset(block, 0, sizeof(block));
 943             } else {
 944                 s->fdct[enc_blk->dct_mode](block);
 945             }
 946
 947             dv_set_class_number(block, enc_blk,
 948                                 enc_blk->dct_mode ? ff_zigzag248_direct : ff_zigzag_direct,
 949                                 enc_blk->dct_mode ? dv_weight_248 : dv_weight_88,
 950                                 j/4);
 951
 952             init_put_bits(pb, ptr, block_sizes[j]/8);
 953             put_bits(pb, 9, (uint16_t)(((enc_blk->mb[0] >> 3) - 1024 + 2) >> 2));
 954             put_bits(pb, 1, enc_blk->dct_mode);
 955             put_bits(pb, 2, enc_blk->cno);
 956
 957             vs_bit_size += enc_blk->bit_size[0] + enc_blk->bit_size[1] +
 958                            enc_blk->bit_size[2] + enc_blk->bit_size[3];
 959             ++enc_blk;
 960             ++pb;
 961             ptr += block_sizes[j]/8;
 962         }
 963     }
 964
 965     if (vs_total_ac_bits < vs_bit_size)
 966         dv_guess_qnos(&enc_blks[0], &qnos[0]);
 967
 968     for (i=0; i<5; i++) {
 969        dif[i*80 + 3] = qnos[i];
 970     }
 971
 972     /* First pass over individual cells only */
 973     for (j=0; j<5*6; j++)
 974        dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j+1]);
 975
 976     /* Second pass over each MB space */
 977     for (j=0; j<5*6; j+=6) {
 978         pb= &pbs[j];
 979         for (i=0; i<6; i++) {
 980             if (enc_blks[i+j].partial_bit_count)
 981                 pb=dv_encode_ac(&enc_blks[i+j], pb, &pbs[j+6]);
 982         }
 983     }
 984
 985     /* Third and final pass over the whole vides segment space */
 986     pb= &pbs[0];
 987     for (j=0; j<5*6; j++) {
 988        if (enc_blks[j].partial_bit_count)
 989            pb=dv_encode_ac(&enc_blks[j], pb, &pbs[6*5]);
 990        if (enc_blks[j].partial_bit_count)
 991             av_log(NULL, AV_LOG_ERROR, "ac bitstream overflow\n");
 992     }
 993
 994     for (j=0; j<5*6; j++)
 995        flush_put_bits(&pbs[j]);
 996 }
 997
 998 static int dv_decode_mt(AVCodecContext *avctx, void* sl)
 999 {
1000     DVVideoContext *s = avctx->priv_data;
1001     int slice = (size_t)sl;
1002
1003     /* which DIF channel is this? */
1004     int chan = slice / (s->sys->difseg_size * 27);
1005
1006     /* slice within the DIF channel */
1007     int chan_slice = slice % (s->sys->difseg_size * 27);
1008
1009     /* byte offset of this channel's data */
1010     int chan_offset = chan * s->sys->difseg_size * 150 * 80;
1011
1012     dv_decode_video_segment(s, &s->buf[((chan_slice/27)*6+(chan_slice/3)+chan_slice*5+7)*80 + chan_offset],
1013                             &s->sys->video_place[slice*5]);
1014     return 0;
1015 }
1016
1017 static int dv_encode_mt(AVCodecContext *avctx, void* sl)
1018 {
1019     DVVideoContext *s = avctx->priv_data;
1020     int slice = (size_t)sl;
1021
1022     /* which DIF channel is this? */
1023     int chan = slice / (s->sys->difseg_size * 27);
1024
1025     /* slice within the DIF channel */
1026     int chan_slice = slice % (s->sys->difseg_size * 27);
1027
1028     /* byte offset of this channel's data */
1029     int chan_offset = chan * s->sys->difseg_size * 150 * 80;
1030
1031     dv_encode_video_segment(s, &s->buf[((chan_slice/27)*6+(chan_slice/3)+chan_slice*5+7)*80 + chan_offset],
1032                             &s->sys->video_place[slice*5]);
1033     return 0;
1034 }
1035
1036 /* NOTE: exactly one frame must be given (120000 bytes for NTSC,
1037    144000 bytes for PAL - or twice those for 50Mbps) */
1038 static int dvvideo_decode_frame(AVCodecContext *avctx,
1039                                  void *data, int *data_size,
1040                                  uint8_t *buf, int buf_size)
1041 {
1042     DVVideoContext *s = avctx->priv_data;
1043
1044     s->sys = dv_frame_profile(buf);
1045     if (!s->sys || buf_size < s->sys->frame_size)
1046         return -1; /* NOTE: we only accept several full frames */
1047
1048     if(s->picture.data[0])
1049         avctx->release_buffer(avctx, &s->picture);
1050
1051     s->picture.reference = 0;
1052     s->picture.key_frame = 1;
1053     s->picture.pict_type = FF_I_TYPE;
1054     avctx->pix_fmt = s->sys->pix_fmt;
1055     avcodec_set_dimensions(avctx, s->sys->width, s->sys->height);
1056     if(avctx->get_buffer(avctx, &s->picture) < 0) {
1057         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1058         return -1;
1059     }
1060     s->picture.interlaced_frame = 1;
1061     s->picture.top_field_first = 0;
1062
1063     s->buf = buf;
1064     avctx->execute(avctx, dv_decode_mt, (void**)&dv_anchor[0], NULL,
1065                    s->sys->n_difchan * s->sys->difseg_size * 27);
1066
1067     emms_c();
1068
1069     /* return image */
1070     *data_size = sizeof(AVFrame);
1071     *(AVFrame*)data= s->picture;
1072
1073     return s->sys->frame_size;
1074 }
1075
1076 static int dvvideo_encode_frame(AVCodecContext *c, uint8_t *buf, int buf_size,
1077                                 void *data)
1078 {
1079     DVVideoContext *s = c->priv_data;
1080
1081     s->sys = dv_codec_profile(c);
1082     if (!s->sys)
1083         return -1;
1084     if(buf_size < s->sys->frame_size)
1085         return -1;
1086
1087     c->pix_fmt = s->sys->pix_fmt;
1088     s->picture = *((AVFrame *)data);
1089     s->picture.key_frame = 1;
1090     s->picture.pict_type = FF_I_TYPE;
1091
1092     s->buf = buf;
1093     c->execute(c, dv_encode_mt, (void**)&dv_anchor[0], NULL,
1094                s->sys->n_difchan * s->sys->difseg_size * 27);
1095
1096     emms_c();
1097
1098     /* Fill in just enough of the header for dv_frame_profile() to
1099        return the correct result, so that the frame can be decoded
1100        correctly. The rest of the metadata is filled in by the dvvideo
1101        avformat. (this should probably change so that encode_frame()
1102        fills in ALL of the metadata - e.g. for Quicktime-wrapped DV
1103        streams) */
1104
1105     /* NTSC/PAL format */
1106     buf[3] = s->sys->dsf ? 0x80 : 0x00;
1107
1108     /* 25Mbps or 50Mbps */
1109     buf[80*5 + 48 + 3] = (s->sys->pix_fmt == PIX_FMT_YUV422P) ? 0x4 : 0x0;
1110
1111     return s->sys->frame_size;
1112 }
1113
1114 static int dvvideo_close(AVCodecContext *c)
1115 {
1116
1117     return 0;
1118 }
1119
1120
1121 #ifdef CONFIG_DVVIDEO_ENCODER
1122 AVCodec dvvideo_encoder = {
1123     "dvvideo",
1124     CODEC_TYPE_VIDEO,
1125     CODEC_ID_DVVIDEO,
1126     sizeof(DVVideoContext),
1127     dvvideo_init,
1128     dvvideo_encode_frame,
1129     dvvideo_close,
1130     NULL,
1131     CODEC_CAP_DR1,
1132     NULL
1133 };
1134 #endif // CONFIG_DVVIDEO_ENCODER
1135
1136 AVCodec dvvideo_decoder = {
1137     "dvvideo",
1138     CODEC_TYPE_VIDEO,
1139     CODEC_ID_DVVIDEO,
1140     sizeof(DVVideoContext),
1141     dvvideo_init,
1142     NULL,
1143     dvvideo_close,
1144     dvvideo_decode_frame,
1145     CODEC_CAP_DR1,
1146     NULL
1147 };