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