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         if (s->sys->pix_fmt == PIX_FMT_YUV422P) {
 474             y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + (mb_x>>1))<<log2_blocksize);
 475             c_offset = ((mb_y * s->picture.linesize[1] + (mb_x >> 2))<<log2_blocksize);
 476         } else { /* 4:1:1 or 4:2:0 */
 477             y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x)<<log2_blocksize);
 478             if (s->sys->pix_fmt == PIX_FMT_YUV411P)
 479                 c_offset = ((mb_y * s->picture.linesize[1] + (mb_x >> 2))<<log2_blocksize);
 480             else /* 4:2:0 */
 481                 c_offset = (((mb_y >> 1) * s->picture.linesize[1] + (mb_x >> 1))<<log2_blocksize);
 482         }
 483         for(j = 0;j < 6; j++) {
 484             idct_put = s->idct_put[mb->dct_mode && log2_blocksize==3];
 485             if (s->sys->pix_fmt == PIX_FMT_YUV422P) { /* 4:2:2 */
 486                 if (j == 0 || j == 2) {
 487                     /* Y0 Y1 */
 488                     idct_put(y_ptr + ((j >> 1)<<log2_blocksize),
 489                              s->picture.linesize[0], block);
 490                 } else if(j > 3) {
 491                     /* Cr Cb */
 492                     idct_put(s->picture.data[6 - j] + c_offset,
 493                              s->picture.linesize[6 - j], block);
 494                 }
 495                 /* note: j=1 and j=3 are "dummy" blocks in 4:2:2 */
 496             } else { /* 4:1:1 or 4:2:0 */
 497                 if (j < 4) {
 498                     if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x < (704 / 8)) {
 499                         /* NOTE: at end of line, the macroblock is handled as 420 */
 500                         idct_put(y_ptr + (j<<log2_blocksize), s->picture.linesize[0], block);
 501                     } else {
 502                         idct_put(y_ptr + (((j & 1) + (j >> 1) * s->picture.linesize[0])<<log2_blocksize),
 503                                  s->picture.linesize[0], block);
 504                     }
 505                 } else {
 506                     if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
 507                         uint64_t aligned_pixels[64/8];
 508                         uint8_t *pixels= (uint8_t*)aligned_pixels;
 509                         uint8_t *c_ptr, *c_ptr1, *ptr, *ptr1;
 510                         int x, y, linesize;
 511                         /* NOTE: at end of line, the macroblock is handled as 420 */
 512                         idct_put(pixels, 8, block);
 513                         linesize = s->picture.linesize[6 - j];
 514                         c_ptr = s->picture.data[6 - j] + c_offset;
 515                         ptr = pixels;
 516                         for(y = 0;y < (1<<log2_blocksize); y++) {
 517                             ptr1= ptr + (1<<(log2_blocksize-1));
 518                             c_ptr1 = c_ptr + (linesize<<log2_blocksize);
 519                             for(x=0; x < (1<<(log2_blocksize-1)); x++){
 520                                 c_ptr[x]= ptr[x]; c_ptr1[x]= ptr1[x];
 521                             }
 522                             c_ptr += linesize;
 523                             ptr += 8;
 524                         }
 525                     } else {
 526                         /* don't ask me why they inverted Cb and Cr ! */
 527                         idct_put(s->picture.data[6 - j] + c_offset,
 528                                  s->picture.linesize[6 - j], block);
 529                     }
 530                 }
 531             }
 532             block += 64;
 533             mb++;
 534         }
 535     }
 536 }
 537
 538 #ifdef DV_CODEC_TINY_TARGET
 539 /* Converts run and level (where level != 0) pair into vlc, returning bit size */
 540 static av_always_inline int dv_rl2vlc(int run, int level, int sign, uint32_t* vlc)
 541 {
 542     int size;
 543     if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
 544         *vlc = dv_vlc_map[run][level].vlc | sign;
 545         size = dv_vlc_map[run][level].size;
 546     }
 547     else {
 548         if (level < DV_VLC_MAP_LEV_SIZE) {
 549             *vlc = dv_vlc_map[0][level].vlc | sign;
 550             size = dv_vlc_map[0][level].size;
 551         } else {
 552             *vlc = 0xfe00 | (level << 1) | sign;
 553             size = 16;
 554         }
 555         if (run) {
 556             *vlc |= ((run < 16) ? dv_vlc_map[run-1][0].vlc :
 557                                   (0x1f80 | (run - 1))) << size;
 558             size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
 559         }
 560     }
 561
 562     return size;
 563 }
 564
 565 static av_always_inline int dv_rl2vlc_size(int run, int level)
 566 {
 567     int size;
 568
 569     if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
 570         size = dv_vlc_map[run][level].size;
 571     }
 572     else {
 573         size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16;
 574         if (run) {
 575             size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
 576         }
 577     }
 578     return size;
 579 }
 580 #else
 581 static av_always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t* vlc)
 582 {
 583     *vlc = dv_vlc_map[run][l].vlc | sign;
 584     return dv_vlc_map[run][l].size;
 585 }
 586
 587 static av_always_inline int dv_rl2vlc_size(int run, int l)
 588 {
 589     return dv_vlc_map[run][l].size;
 590 }
 591 #endif
 592
 593 typedef struct EncBlockInfo {
 594     int area_q[4];
 595     int bit_size[4];
 596     int prev[5];
 597     int cur_ac;
 598     int cno;
 599     int dct_mode;
 600     DCTELEM mb[64];
 601     uint8_t next[64];
 602     uint8_t sign[64];
 603     uint8_t partial_bit_count;
 604     uint32_t partial_bit_buffer; /* we can't use uint16_t here */
 605 } EncBlockInfo;
 606
 607 static av_always_inline PutBitContext* dv_encode_ac(EncBlockInfo* bi, PutBitContext* pb_pool,
 608                                        PutBitContext* pb_end)
 609 {
 610     int prev;
 611     int bits_left;
 612     PutBitContext* pb = pb_pool;
 613     int size = bi->partial_bit_count;
 614     uint32_t vlc = bi->partial_bit_buffer;
 615
 616     bi->partial_bit_count = bi->partial_bit_buffer = 0;
 617     for(;;){
 618        /* Find suitable storage space */
 619        for (; size > (bits_left = put_bits_left(pb)); pb++) {
 620           if (bits_left) {
 621               size -= bits_left;
 622               put_bits(pb, bits_left, vlc >> size);
 623               vlc = vlc & ((1<<size)-1);
 624           }
 625           if (pb + 1 >= pb_end) {
 626               bi->partial_bit_count = size;
 627               bi->partial_bit_buffer = vlc;
 628               return pb;
 629           }
 630        }
 631
 632        /* Store VLC */
 633        put_bits(pb, size, vlc);
 634
 635        if(bi->cur_ac>=64)
 636            break;
 637
 638        /* Construct the next VLC */
 639        prev= bi->cur_ac;
 640        bi->cur_ac = bi->next[prev];
 641        if(bi->cur_ac < 64){
 642            size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac], bi->sign[bi->cur_ac], &vlc);
 643        } else {
 644            size = 4; vlc = 6; /* End Of Block stamp */
 645        }
 646     }
 647     return pb;
 648 }
 649
 650 static av_always_inline void dv_set_class_number(DCTELEM* blk, EncBlockInfo* bi,
 651                                               const uint8_t* zigzag_scan, const int *weight, int bias)
 652 {
 653     int i, area;
 654     /* We offer two different methods for class number assignment: the
 655        method suggested in SMPTE 314M Table 22, and an improved
 656        method. The SMPTE method is very conservative; it assigns class
 657        3 (i.e. severe quantization) to any block where the largest AC
 658        component is greater than 36. ffmpeg's DV encoder tracks AC bit
 659        consumption precisely, so there is no need to bias most blocks
 660        towards strongly lossy compression. Instead, we assign class 2
 661        to most blocks, and use class 3 only when strictly necessary
 662        (for blocks whose largest AC component exceeds 255). */
 663
 664 #if 0 /* SMPTE spec method */
 665     static const int classes[] = {12, 24, 36, 0xffff};
 666 #else /* improved ffmpeg method */
 667     static const int classes[] = {-1, -1, 255, 0xffff};
 668 #endif
 669     int max=classes[0];
 670     int prev=0;
 671
 672     bi->mb[0] = blk[0];
 673
 674     for (area = 0; area < 4; area++) {
 675        bi->prev[area] = prev;
 676        bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
 677        for (i=mb_area_start[area]; i<mb_area_start[area+1]; i++) {
 678           int level = blk[zigzag_scan[i]];
 679
 680           if (level+15 > 30U) {
 681               bi->sign[i] = (level>>31)&1;
 682               /* weigh it and and shift down into range, adding for rounding */
 683               /* the extra division by a factor of 2^4 reverses the 8x expansion of the DCT
 684                  AND the 2x doubling of the weights */
 685               level = (FFABS(level) * weight[i] + (1<<(dv_weight_bits+3))) >> (dv_weight_bits+4);
 686               bi->mb[i] = level;
 687               if(level>max) max= level;
 688               bi->bit_size[area] += dv_rl2vlc_size(i - prev  - 1, level);
 689               bi->next[prev]= i;
 690               prev= i;
 691           }
 692        }
 693     }
 694     bi->next[prev]= i;
 695     for(bi->cno = 0; max > classes[bi->cno]; bi->cno++);
 696
 697     bi->cno += bias;
 698
 699     if (bi->cno >= 3) {
 700         bi->cno = 3;
 701         prev=0;
 702         i= bi->next[prev];
 703         for (area = 0; area < 4; area++) {
 704             bi->prev[area] = prev;
 705             bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
 706             for (; i<mb_area_start[area+1]; i= bi->next[i]) {
 707                 bi->mb[i] >>=1;
 708
 709                 if (bi->mb[i]) {
 710                     bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]);
 711                     bi->next[prev]= i;
 712                     prev= i;
 713                 }
 714             }
 715         }
 716         bi->next[prev]= i;
 717     }
 718 }
 719
 720 //FIXME replace this by dsputil
 721 #define SC(x, y) ((s[x] - s[y]) ^ ((s[x] - s[y]) >> 7))
 722 static av_always_inline int dv_guess_dct_mode(DCTELEM *blk) {
 723     DCTELEM *s;
 724     int score88 = 0;
 725     int score248 = 0;
 726     int i;
 727
 728     /* Compute 8-8 score (small values give a better chance for 8-8 DCT) */
 729     s = blk;
 730     for(i=0; i<7; i++) {
 731         score88 += SC(0,  8) + SC(1, 9) + SC(2, 10) + SC(3, 11) +
 732                    SC(4, 12) + SC(5,13) + SC(6, 14) + SC(7, 15);
 733         s += 8;
 734     }
 735     /* Compute 2-4-8 score (small values give a better chance for 2-4-8 DCT) */
 736     s = blk;
 737     for(i=0; i<6; i++) {
 738         score248 += SC(0, 16) + SC(1,17) + SC(2, 18) + SC(3, 19) +
 739                     SC(4, 20) + SC(5,21) + SC(6, 22) + SC(7, 23);
 740         s += 8;
 741     }
 742
 743     return (score88 - score248 > -10);
 744 }
 745
 746 static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos)
 747 {
 748     int size[5];
 749     int i, j, k, a, prev, a2;
 750     EncBlockInfo* b;
 751
 752     size[0] = size[1] = size[2] = size[3] = size[4] = 1<<24;
 753     do {
 754        b = blks;
 755        for (i=0; i<5; i++) {
 756           if (!qnos[i])
 757               continue;
 758
 759           qnos[i]--;
 760           size[i] = 0;
 761           for (j=0; j<6; j++, b++) {
 762              for (a=0; a<4; a++) {
 763                 if (b->area_q[a] != dv_quant_shifts[qnos[i] + dv_quant_offset[b->cno]][a]) {
 764                     b->bit_size[a] = 1; // 4 areas 4 bits for EOB :)
 765                     b->area_q[a]++;
 766                     prev= b->prev[a];
 767                     assert(b->next[prev] >= mb_area_start[a+1] || b->mb[prev]);
 768                     for (k= b->next[prev] ; k<mb_area_start[a+1]; k= b->next[k]) {
 769                        b->mb[k] >>= 1;
 770                        if (b->mb[k]) {
 771                            b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
 772                            prev= k;
 773                        } else {
 774                            if(b->next[k] >= mb_area_start[a+1] && b->next[k]<64){
 775                                 for(a2=a+1; b->next[k] >= mb_area_start[a2+1]; a2++)
 776                                     b->prev[a2] = prev;
 777                                 assert(a2<4);
 778                                 assert(b->mb[b->next[k]]);
 779                                 b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]])
 780                                                   -dv_rl2vlc_size(b->next[k] -    k - 1, b->mb[b->next[k]]);
 781                                 assert(b->prev[a2]==k && (a2+1 >= 4 || b->prev[a2+1]!=k));
 782                                 b->prev[a2] = prev;
 783                            }
 784                            b->next[prev] = b->next[k];
 785                        }
 786                     }
 787                     b->prev[a+1]= prev;
 788                 }
 789                 size[i] += b->bit_size[a];
 790              }
 791           }
 792           if(vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4])
 793                 return;
 794        }
 795     } while (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4]);
 796
 797
 798     for(a=2; a==2 || vs_total_ac_bits < size[0]; a+=a){
 799         b = blks;
 800         size[0] = 5*6*4; //EOB
 801         for (j=0; j<6*5; j++, b++) {
 802             prev= b->prev[0];
 803             for (k= b->next[prev]; k<64; k= b->next[k]) {
 804                 if(b->mb[k] < a && b->mb[k] > -a){
 805                     b->next[prev] = b->next[k];
 806                 }else{
 807                     size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
 808                     prev= k;
 809                 }
 810             }
 811         }
 812     }
 813 }
 814
 815 static inline void dv_encode_video_segment(DVVideoContext *s,
 816                                            uint8_t *dif,
 817                                            const uint16_t *mb_pos_ptr)
 818 {
 819     int mb_index, i, j, v;
 820     int mb_x, mb_y, c_offset, linesize;
 821     uint8_t*  y_ptr;
 822     uint8_t*  data;
 823     uint8_t*  ptr;
 824     int       do_edge_wrap;
 825     DECLARE_ALIGNED_16(DCTELEM, block[64]);
 826     EncBlockInfo  enc_blks[5*6];
 827     PutBitContext pbs[5*6];
 828     PutBitContext* pb;
 829     EncBlockInfo* enc_blk;
 830     int       vs_bit_size = 0;
 831     int       qnos[5];
 832
 833     assert((((int)block) & 15) == 0);
 834
 835     enc_blk = &enc_blks[0];
 836     pb = &pbs[0];
 837     for(mb_index = 0; mb_index < 5; mb_index++) {
 838         v = *mb_pos_ptr++;
 839         mb_x = v & 0xff;
 840         mb_y = v >> 8;
 841         if (s->sys->pix_fmt == PIX_FMT_YUV422P) {
 842             y_ptr = s->picture.data[0] + (mb_y * s->picture.linesize[0] * 8) + (mb_x * 4);
 843         } else { /* 4:1:1 */
 844             y_ptr = s->picture.data[0] + (mb_y * s->picture.linesize[0] * 8) + (mb_x * 8);
 845         }
 846         if (s->sys->pix_fmt == PIX_FMT_YUV420P) {
 847             c_offset = (((mb_y >> 1) * s->picture.linesize[1] * 8) + ((mb_x >> 1) * 8));
 848         } else { /* 4:2:2 or 4:1:1 */
 849             c_offset = ((mb_y * s->picture.linesize[1] * 8) + ((mb_x >> 2) * 8));
 850         }
 851         do_edge_wrap = 0;
 852         qnos[mb_index] = 15; /* No quantization */
 853         ptr = dif + mb_index*80 + 4;
 854         for(j = 0;j < 6; j++) {
 855             int dummy = 0;
 856             if (s->sys->pix_fmt == PIX_FMT_YUV422P) { /* 4:2:2 */
 857                 if (j == 0 || j == 2) {
 858                     /* Y0 Y1 */
 859                     data = y_ptr + ((j>>1) * 8);
 860                     linesize = s->picture.linesize[0];
 861                 } else if (j > 3) {
 862                     /* Cr Cb */
 863                     data = s->picture.data[6 - j] + c_offset;
 864                     linesize = s->picture.linesize[6 - j];
 865                 } else {
 866                     /* j=1 and j=3 are "dummy" blocks, used for AC data only */
 867                     data = 0;
 868                     linesize = 0;
 869                     dummy = 1;
 870                 }
 871             } else { /* 4:1:1 or 4:2:0 */
 872                 if (j < 4) {  /* Four Y blocks */
 873                     /* NOTE: at end of line, the macroblock is handled as 420 */
 874                     if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x < (704 / 8)) {
 875                         data = y_ptr + (j * 8);
 876                     } else {
 877                         data = y_ptr + ((j & 1) * 8) + ((j >> 1) * 8 * s->picture.linesize[0]);
 878                     }
 879                     linesize = s->picture.linesize[0];
 880                 } else {      /* Cr and Cb blocks */
 881                     /* don't ask Fabrice why they inverted Cb and Cr ! */
 882                     data = s->picture.data[6 - j] + c_offset;
 883                     linesize = s->picture.linesize[6 - j];
 884                     if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8))
 885                         do_edge_wrap = 1;
 886                 }
 887             }
 888
 889             /* Everything is set up -- now just copy data -> DCT block */
 890             if (do_edge_wrap) {  /* Edge wrap copy: 4x16 -> 8x8 */
 891                 uint8_t* d;
 892                 DCTELEM *b = block;
 893                 for (i=0;i<8;i++) {
 894                    d = data + 8 * linesize;
 895                    b[0] = data[0]; b[1] = data[1]; b[2] = data[2]; b[3] = data[3];
 896                    b[4] =    d[0]; b[5] =    d[1]; b[6] =    d[2]; b[7] =    d[3];
 897                    data += linesize;
 898                    b += 8;
 899                 }
 900             } else {             /* Simple copy: 8x8 -> 8x8 */
 901                 if (!dummy)
 902                     s->get_pixels(block, data, linesize);
 903             }
 904
 905             if(s->avctx->flags & CODEC_FLAG_INTERLACED_DCT)
 906                 enc_blk->dct_mode = dv_guess_dct_mode(block);
 907             else
 908                 enc_blk->dct_mode = 0;
 909             enc_blk->area_q[0] = enc_blk->area_q[1] = enc_blk->area_q[2] = enc_blk->area_q[3] = 0;
 910             enc_blk->partial_bit_count = 0;
 911             enc_blk->partial_bit_buffer = 0;
 912             enc_blk->cur_ac = 0;
 913
 914             if (dummy) {
 915                 /* We rely on the fact that encoding all zeros leads to an immediate EOB,
 916                    which is precisely what the spec calls for in the "dummy" blocks. */
 917                 memset(block, 0, sizeof(block));
 918             } else {
 919                 s->fdct[enc_blk->dct_mode](block);
 920             }
 921
 922             dv_set_class_number(block, enc_blk,
 923                                 enc_blk->dct_mode ? ff_zigzag248_direct : ff_zigzag_direct,
 924                                 enc_blk->dct_mode ? dv_weight_248 : dv_weight_88,
 925                                 j/4);
 926
 927             init_put_bits(pb, ptr, block_sizes[j]/8);
 928             put_bits(pb, 9, (uint16_t)(((enc_blk->mb[0] >> 3) - 1024 + 2) >> 2));
 929             put_bits(pb, 1, enc_blk->dct_mode);
 930             put_bits(pb, 2, enc_blk->cno);
 931
 932             vs_bit_size += enc_blk->bit_size[0] + enc_blk->bit_size[1] +
 933                            enc_blk->bit_size[2] + enc_blk->bit_size[3];
 934             ++enc_blk;
 935             ++pb;
 936             ptr += block_sizes[j]/8;
 937         }
 938     }
 939
 940     if (vs_total_ac_bits < vs_bit_size)
 941         dv_guess_qnos(&enc_blks[0], &qnos[0]);
 942
 943     for (i=0; i<5; i++) {
 944        dif[i*80 + 3] = qnos[i];
 945     }
 946
 947     /* First pass over individual cells only */
 948     for (j=0; j<5*6; j++)
 949        dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j+1]);
 950
 951     /* Second pass over each MB space */
 952     for (j=0; j<5*6; j+=6) {
 953         pb= &pbs[j];
 954         for (i=0; i<6; i++) {
 955             if (enc_blks[i+j].partial_bit_count)
 956                 pb=dv_encode_ac(&enc_blks[i+j], pb, &pbs[j+6]);
 957         }
 958     }
 959
 960     /* Third and final pass over the whole vides segment space */
 961     pb= &pbs[0];
 962     for (j=0; j<5*6; j++) {
 963        if (enc_blks[j].partial_bit_count)
 964            pb=dv_encode_ac(&enc_blks[j], pb, &pbs[6*5]);
 965        if (enc_blks[j].partial_bit_count)
 966             av_log(NULL, AV_LOG_ERROR, "ac bitstream overflow\n");
 967     }
 968
 969     for (j=0; j<5*6; j++)
 970        flush_put_bits(&pbs[j]);
 971 }
 972
 973 static int dv_decode_mt(AVCodecContext *avctx, void* sl)
 974 {
 975     DVVideoContext *s = avctx->priv_data;
 976     int slice = (size_t)sl;
 977
 978     /* which DIF channel is this? */
 979     int chan = slice / (s->sys->difseg_size * 27);
 980
 981     /* slice within the DIF channel */
 982     int chan_slice = slice % (s->sys->difseg_size * 27);
 983
 984     /* byte offset of this channel's data */
 985     int chan_offset = chan * s->sys->difseg_size * 150 * 80;
 986
 987     dv_decode_video_segment(s, &s->buf[((chan_slice/27)*6+(chan_slice/3)+chan_slice*5+7)*80 + chan_offset],
 988                             &s->sys->video_place[slice*5]);
 989     return 0;
 990 }
 991
 992 #ifdef CONFIG_DVVIDEO_ENCODER
 993 static int dv_encode_mt(AVCodecContext *avctx, void* sl)
 994 {
 995     DVVideoContext *s = avctx->priv_data;
 996     int slice = (size_t)sl;
 997
 998     /* which DIF channel is this? */
 999     int chan = slice / (s->sys->difseg_size * 27);
1000
1001     /* slice within the DIF channel */
1002     int chan_slice = slice % (s->sys->difseg_size * 27);
1003
1004     /* byte offset of this channel's data */
1005     int chan_offset = chan * s->sys->difseg_size * 150 * 80;
1006
1007     dv_encode_video_segment(s, &s->buf[((chan_slice/27)*6+(chan_slice/3)+chan_slice*5+7)*80 + chan_offset],
1008                             &s->sys->video_place[slice*5]);
1009     return 0;
1010 }
1011 #endif
1012
1013 #ifdef CONFIG_DECODERS
1014 /* NOTE: exactly one frame must be given (120000 bytes for NTSC,
1015    144000 bytes for PAL - or twice those for 50Mbps) */
1016 static int dvvideo_decode_frame(AVCodecContext *avctx,
1017                                  void *data, int *data_size,
1018                                  const uint8_t *buf, int buf_size)
1019 {
1020     DVVideoContext *s = avctx->priv_data;
1021
1022     s->sys = dv_frame_profile(buf);
1023     if (!s->sys || buf_size < s->sys->frame_size)
1024         return -1; /* NOTE: we only accept several full frames */
1025
1026     if(s->picture.data[0])
1027         avctx->release_buffer(avctx, &s->picture);
1028
1029     s->picture.reference = 0;
1030     s->picture.key_frame = 1;
1031     s->picture.pict_type = FF_I_TYPE;
1032     avctx->pix_fmt = s->sys->pix_fmt;
1033     avctx->time_base = (AVRational){s->sys->frame_rate_base, s->sys->frame_rate};
1034     avcodec_set_dimensions(avctx, s->sys->width, s->sys->height);
1035     if(avctx->get_buffer(avctx, &s->picture) < 0) {
1036         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1037         return -1;
1038     }
1039     s->picture.interlaced_frame = 1;
1040     s->picture.top_field_first = 0;
1041
1042     s->buf = buf;
1043     avctx->execute(avctx, dv_decode_mt, (void**)&dv_anchor[0], NULL,
1044                    s->sys->n_difchan * s->sys->difseg_size * 27);
1045
1046     emms_c();
1047
1048     /* return image */
1049     *data_size = sizeof(AVFrame);
1050     *(AVFrame*)data= s->picture;
1051
1052     return s->sys->frame_size;
1053 }
1054 #endif
1055
1056
1057 static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c, uint8_t* buf)
1058 {
1059     /*
1060      * Here's what SMPTE314M says about these two:
1061      *    (page 6) APTn, AP1n, AP2n, AP3n: These data shall be identical
1062      *             as track application IDs (APTn = 001, AP1n =
1063      *             001, AP2n = 001, AP3n = 001), if the source signal
1064      *             comes from a digital VCR. If the signal source is
1065      *             unknown, all bits for these data shall be set to 1.
1066      *    (page 12) STYPE: STYPE defines a signal type of video signal
1067      *                     00000b = 4:1:1 compression
1068      *                     00100b = 4:2:2 compression
1069      *                     XXXXXX = Reserved
1070      * Now, I've got two problems with these statements:
1071      *   1. it looks like APT == 111b should be a safe bet, but it isn't.
1072      *      It seems that for PAL as defined in IEC 61834 we have to set
1073      *      APT to 000 and for SMPTE314M to 001.
1074      *   2. It is not at all clear what STYPE is used for 4:2:0 PAL
1075      *      compression scheme (if any).
1076      */
1077     int apt = (c->sys->pix_fmt == PIX_FMT_YUV420P ? 0 : 1);
1078     int stype = (c->sys->pix_fmt == PIX_FMT_YUV422P ? 4 : 0);
1079
1080     uint8_t aspect = 0;
1081     if((int)(av_q2d(c->avctx->sample_aspect_ratio) * c->avctx->width / c->avctx->height * 10) == 17) /* 16:9 */
1082         aspect = 0x02;
1083
1084     buf[0] = (uint8_t)pack_id;
1085     switch (pack_id) {
1086     case dv_header525: /* I can't imagine why these two weren't defined as real */
1087     case dv_header625: /* packs in SMPTE314M -- they definitely look like ones */
1088           buf[1] = 0xf8 |               /* reserved -- always 1 */
1089                    (apt & 0x07);        /* APT: Track application ID */
1090           buf[2] = (0 << 7)    | /* TF1: audio data is 0 - valid; 1 - invalid */
1091                    (0x0f << 3) | /* reserved -- always 1 */
1092                    (apt & 0x07); /* AP1: Audio application ID */
1093           buf[3] = (0 << 7)    | /* TF2: video data is 0 - valid; 1 - invalid */
1094                    (0x0f << 3) | /* reserved -- always 1 */
1095                    (apt & 0x07); /* AP2: Video application ID */
1096           buf[4] = (0 << 7)    | /* TF3: subcode(SSYB) is 0 - valid; 1 - invalid */
1097                    (0x0f << 3) | /* reserved -- always 1 */
1098                    (apt & 0x07); /* AP3: Subcode application ID */
1099           break;
1100     case dv_video_source:
1101           buf[1] = 0xff; /* reserved -- always 1 */
1102           buf[2] = (1 << 7) | /* B/W: 0 - b/w, 1 - color */
1103                    (1 << 6) | /* following CLF is valid - 0, invalid - 1 */
1104                    (3 << 4) | /* CLF: color frames id (see ITU-R BT.470-4) */
1105                    0xf; /* reserved -- always 1 */
1106           buf[3] = (3 << 6) | /* reserved -- always 1 */
1107                    (c->sys->dsf << 5) | /*  system: 60fields/50fields */
1108                    stype; /* signal type video compression */
1109           buf[4] = 0xff; /* VISC: 0xff -- no information */
1110           break;
1111     case dv_video_control:
1112           buf[1] = (0 << 6) | /* Copy generation management (CGMS) 0 -- free */
1113                    0x3f; /* reserved -- always 1 */
1114           buf[2] = 0xc8 | /* reserved -- always b11001xxx */
1115                    aspect;
1116           buf[3] = (1 << 7) | /* Frame/field flag 1 -- frame, 0 -- field */
1117                    (1 << 6) | /* First/second field flag 0 -- field 2, 1 -- field 1 */
1118                    (1 << 5) | /* Frame change flag 0 -- same picture as before, 1 -- different */
1119                    (1 << 4) | /* 1 - interlaced, 0 - noninterlaced */
1120                    0xc; /* reserved -- always b1100 */
1121           buf[4] = 0xff; /* reserved -- always 1 */
1122           break;
1123     default:
1124           buf[1] = buf[2] = buf[3] = buf[4] = 0xff;
1125     }
1126     return 5;
1127 }
1128
1129 #ifdef CONFIG_DVVIDEO_ENCODER
1130 static void dv_format_frame(DVVideoContext* c, uint8_t* buf)
1131 {
1132     int chan, i, j, k;
1133
1134     for (chan = 0; chan < c->sys->n_difchan; chan++) {
1135         for (i = 0; i < c->sys->difseg_size; i++) {
1136             memset(buf, 0xff, 80 * 6); /* First 6 DIF blocks are for control data */
1137
1138             /* DV header: 1DIF */
1139             buf += dv_write_dif_id(dv_sect_header, chan, i, 0, buf);
1140             buf += dv_write_pack((c->sys->dsf ? dv_header625 : dv_header525), c, buf);
1141             buf += 72; /* unused bytes */
1142
1143             /* DV subcode: 2DIFs */
1144             for (j = 0; j < 2; j++) {
1145                 buf += dv_write_dif_id(dv_sect_subcode, chan, i, j, buf);
1146                 for (k = 0; k < 6; k++)
1147                      buf += dv_write_ssyb_id(k, (i < c->sys->difseg_size/2), buf) + 5;
1148                 buf += 29; /* unused bytes */
1149             }
1150
1151             /* DV VAUX: 3DIFS */
1152             for (j = 0; j < 3; j++) {
1153                 buf += dv_write_dif_id(dv_sect_vaux, chan, i, j, buf);
1154                 buf += dv_write_pack(dv_video_source,  c, buf);
1155                 buf += dv_write_pack(dv_video_control, c, buf);
1156                 buf += 7*5;
1157                 buf += dv_write_pack(dv_video_source,  c, buf);
1158                 buf += dv_write_pack(dv_video_control, c, buf);
1159                 buf += 4*5 + 2; /* unused bytes */
1160             }
1161
1162             /* DV Audio/Video: 135 Video DIFs + 9 Audio DIFs */
1163             for (j = 0; j < 135; j++) {
1164                 if (j%15 == 0) {
1165                     memset(buf, 0xff, 80);
1166                     buf += dv_write_dif_id(dv_sect_audio, chan, i, j/15, buf);
1167                     buf += 77; /* audio control & shuffled PCM audio */
1168                 }
1169                 buf += dv_write_dif_id(dv_sect_video, chan, i, j, buf);
1170                 buf += 77; /* 1 video macro block: 1 bytes control
1171                               4 * 14 bytes Y 8x8 data
1172                               10 bytes Cr 8x8 data
1173                               10 bytes Cb 8x8 data */
1174             }
1175         }
1176     }
1177 }
1178
1179
1180 static int dvvideo_encode_frame(AVCodecContext *c, uint8_t *buf, int buf_size,
1181                                 void *data)
1182 {
1183     DVVideoContext *s = c->priv_data;
1184
1185     s->sys = dv_codec_profile(c);
1186     if (!s->sys)
1187         return -1;
1188     if(buf_size < s->sys->frame_size)
1189         return -1;
1190
1191     c->pix_fmt = s->sys->pix_fmt;
1192     s->picture = *((AVFrame *)data);
1193     s->picture.key_frame = 1;
1194     s->picture.pict_type = FF_I_TYPE;
1195
1196     s->buf = buf;
1197     c->execute(c, dv_encode_mt, (void**)&dv_anchor[0], NULL,
1198                s->sys->n_difchan * s->sys->difseg_size * 27);
1199
1200     emms_c();
1201
1202     dv_format_frame(s, buf);
1203
1204     return s->sys->frame_size;
1205 }
1206 #endif
1207
1208 static int dvvideo_close(AVCodecContext *c)
1209 {
1210     DVVideoContext *s = c->priv_data;
1211
1212     if(s->picture.data[0])
1213         c->release_buffer(c, &s->picture);
1214
1215     return 0;
1216 }
1217
1218
1219 #ifdef CONFIG_DVVIDEO_ENCODER
1220 AVCodec dvvideo_encoder = {
1221     "dvvideo",
1222     CODEC_TYPE_VIDEO,
1223     CODEC_ID_DVVIDEO,
1224     sizeof(DVVideoContext),
1225     dvvideo_init,
1226     dvvideo_encode_frame,
1227     .pix_fmts = (enum PixelFormat[]) {PIX_FMT_YUV411P, PIX_FMT_YUV422P, PIX_FMT_YUV420P, PIX_FMT_NONE},
1228     .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
1229 };
1230 #endif // CONFIG_DVVIDEO_ENCODER
1231
1232 #ifdef CONFIG_DVVIDEO_DECODER
1233 AVCodec dvvideo_decoder = {
1234     "dvvideo",
1235     CODEC_TYPE_VIDEO,
1236     CODEC_ID_DVVIDEO,
1237     sizeof(DVVideoContext),
1238     dvvideo_init,
1239     NULL,
1240     dvvideo_close,
1241     dvvideo_decode_frame,
1242     CODEC_CAP_DR1,
1243     NULL,
1244     .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
1245 };
1246 #endif