falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
5553 Commits
32 Branches
570MB
Tree: c17be81763
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'c17be81763'
${ noResults }
FFmpeg/libavcodec/dv.c

1148 lines
38KB
Raw Blame History 

  1. /*

  2.  * DV decoder

  3.  * Copyright (c) 2002 Fabrice Bellard.

  4.  * Copyright (c) 2004 Roman Shaposhnik.

  5.  *

  6.  * DV encoder

  7.  * Copyright (c) 2003 Roman Shaposhnik.

  8.  *

  9.  * 50 Mbps (DVCPRO50) support

  10.  * Copyright (c) 2006 Daniel Maas <dmaas@maasdigital.com>

  11.  *

  12.  * Many thanks to Dan Dennedy <dan@dennedy.org> for providing wealth

  13.  * of DV technical info.

  14.  *

  15.  * This library is free software; you can redistribute it and/or

  16.  * modify it under the terms of the GNU Lesser General Public

  17.  * License as published by the Free Software Foundation; either

  18.  * version 2 of the License, or (at your option) any later version.

  19.  *

  20.  * This library is distributed in the hope that it will be useful,

  21.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  22.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

  23.  * Lesser General Public License for more details.

  24.  *

  25.  * You should have received a copy of the GNU Lesser General Public

  26.  * License along with this library; if not, write to the Free Software

  27.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

  28.  */

  29. 

  30. /**

  31.  * @file dv.c

  32.  * DV codec.

  33.  */

  34. #include "avcodec.h"

  35. #include "dsputil.h"

  36. #include "mpegvideo.h"

  37. #include "simple_idct.h"

  38. #include "dvdata.h"

  39. 

  40. //#undef NDEBUG

  41. //#include <assert.h>

  42. 

  43. typedef struct DVVideoContext {

  44.     const DVprofile* sys;

  45.     AVFrame picture;

  46.     AVCodecContext *avctx;

  47.     uint8_t *buf;

  48. 

  49.     uint8_t dv_zigzag[2][64];

  50.     uint8_t dv_idct_shift[2][2][22][64];

  51. 

  52.     void (*get_pixels)(DCTELEM *block, const uint8_t *pixels, int line_size);

  53.     void (*fdct[2])(DCTELEM *block);

  54.     void (*idct_put[2])(uint8_t *dest, int line_size, DCTELEM *block);

  55. } DVVideoContext;

  56. 

  57. /* MultiThreading - dv_anchor applies to entire DV codec, not just the avcontext */

  58. /* one element is needed for each video segment in a DV frame */

  59. /* at most there are 2 DIF channels * 12 DIF sequences * 27 video segments (PAL 50Mbps) */

  60. #define DV_ANCHOR_SIZE (2*12*27)

  61. 

  62. static void* dv_anchor[DV_ANCHOR_SIZE];

  63. 

  64. #define TEX_VLC_BITS 9

  65. 

  66. #ifdef DV_CODEC_TINY_TARGET

  67. #define DV_VLC_MAP_RUN_SIZE 15

  68. #define DV_VLC_MAP_LEV_SIZE 23

  69. #else

  70. #define DV_VLC_MAP_RUN_SIZE  64

  71. #define DV_VLC_MAP_LEV_SIZE 512 //FIXME sign was removed so this should be /2 but needs check

  72. #endif

  73. 

  74. /* XXX: also include quantization */

  75. static RL_VLC_ELEM *dv_rl_vlc;

  76. /* VLC encoding lookup table */

  77. static struct dv_vlc_pair {

  78.    uint32_t vlc;

  79.    uint8_t  size;

  80. } (*dv_vlc_map)[DV_VLC_MAP_LEV_SIZE] = NULL;

  81. 

  82. static void dv_build_unquantize_tables(DVVideoContext *s, uint8_t* perm)

  83. {

  84.     int i, q, j;

  85. 

  86.     /* NOTE: max left shift is 6 */

  87.     for(q = 0; q < 22; q++) {

  88.         /* 88DCT */

  89.         for(i = 1; i < 64; i++) {

  90.             /* 88 table */

  91.             j = perm[i];

  92.             s->dv_idct_shift[0][0][q][j] =

  93.                 dv_quant_shifts[q][dv_88_areas[i]] + 1;

  94.             s->dv_idct_shift[1][0][q][j] = s->dv_idct_shift[0][0][q][j] + 1;

  95.         }

  96. 

  97.         /* 248DCT */

  98.         for(i = 1; i < 64; i++) {

  99.             /* 248 table */

  100.             s->dv_idct_shift[0][1][q][i] =

  101.                 dv_quant_shifts[q][dv_248_areas[i]] + 1;

  102.             s->dv_idct_shift[1][1][q][i] = s->dv_idct_shift[0][1][q][i] + 1;

  103.         }

  104.     }

  105. }

  106. 

  107. static int dvvideo_init(AVCodecContext *avctx)

  108. {

  109.     DVVideoContext *s = avctx->priv_data;

  110.     DSPContext dsp;

  111.     static int done=0;

  112.     int i, j;

  113. 

  114.     if (!done) {

  115.         VLC dv_vlc;

  116.         uint16_t new_dv_vlc_bits[NB_DV_VLC*2];

  117.         uint8_t new_dv_vlc_len[NB_DV_VLC*2];

  118.         uint8_t new_dv_vlc_run[NB_DV_VLC*2];

  119.         int16_t new_dv_vlc_level[NB_DV_VLC*2];

  120. 

  121.         done = 1;

  122. 

  123.         dv_vlc_map = av_mallocz_static(DV_VLC_MAP_LEV_SIZE*DV_VLC_MAP_RUN_SIZE*sizeof(struct dv_vlc_pair));

  124.         if (!dv_vlc_map)

  125.             return -ENOMEM;

  126. 

  127.         /* dv_anchor lets each thread know its Id */

  128.         for (i=0; i<DV_ANCHOR_SIZE; i++)

  129.             dv_anchor[i] = (void*)(size_t)i;

  130. 

  131.         /* it's faster to include sign bit in a generic VLC parsing scheme */

  132.         for (i=0, j=0; i<NB_DV_VLC; i++, j++) {

  133.             new_dv_vlc_bits[j] = dv_vlc_bits[i];

  134.             new_dv_vlc_len[j] = dv_vlc_len[i];

  135.             new_dv_vlc_run[j] = dv_vlc_run[i];

  136.             new_dv_vlc_level[j] = dv_vlc_level[i];

  137. 

  138.             if (dv_vlc_level[i]) {

  139.                 new_dv_vlc_bits[j] <<= 1;

  140.                 new_dv_vlc_len[j]++;

  141. 

  142.                 j++;

  143.                 new_dv_vlc_bits[j] = (dv_vlc_bits[i] << 1) | 1;

  144.                 new_dv_vlc_len[j] = dv_vlc_len[i] + 1;

  145.                 new_dv_vlc_run[j] = dv_vlc_run[i];

  146.                 new_dv_vlc_level[j] = -dv_vlc_level[i];

  147.             }

  148.         }

  149. 

  150.         /* NOTE: as a trick, we use the fact the no codes are unused

  151.            to accelerate the parsing of partial codes */

  152.         init_vlc(&dv_vlc, TEX_VLC_BITS, j,

  153.                  new_dv_vlc_len, 1, 1, new_dv_vlc_bits, 2, 2, 0);

  154. 

  155.         dv_rl_vlc = av_mallocz_static(dv_vlc.table_size * sizeof(RL_VLC_ELEM));

  156.         if (!dv_rl_vlc)

  157.             return -ENOMEM;

  158. 

  159.         for(i = 0; i < dv_vlc.table_size; i++){

  160.             int code= dv_vlc.table[i][0];

  161.             int len = dv_vlc.table[i][1];

  162.             int level, run;

  163. 

  164.             if(len<0){ //more bits needed

  165.                 run= 0;

  166.                 level= code;

  167.             } else {

  168.                 run=   new_dv_vlc_run[code] + 1;

  169.                 level= new_dv_vlc_level[code];

  170.             }

  171.             dv_rl_vlc[i].len = len;

  172.             dv_rl_vlc[i].level = level;

  173.             dv_rl_vlc[i].run = run;

  174.         }

  175.         free_vlc(&dv_vlc);

  176. 

  177.         for (i = 0; i < NB_DV_VLC - 1; i++) {

  178.            if (dv_vlc_run[i] >= DV_VLC_MAP_RUN_SIZE)

  179.                continue;

  180. #ifdef DV_CODEC_TINY_TARGET

  181.            if (dv_vlc_level[i] >= DV_VLC_MAP_LEV_SIZE)

  182.                continue;

  183. #endif

  184. 

  185.            if (dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].size != 0)

  186.                continue;

  187. 

  188.            dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].vlc = dv_vlc_bits[i] <<

  189.                                                             (!!dv_vlc_level[i]);

  190.            dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].size = dv_vlc_len[i] +

  191.                                                              (!!dv_vlc_level[i]);

  192.         }

  193.         for (i = 0; i < DV_VLC_MAP_RUN_SIZE; i++) {

  194. #ifdef DV_CODEC_TINY_TARGET

  195.            for (j = 1; j < DV_VLC_MAP_LEV_SIZE; j++) {

  196.               if (dv_vlc_map[i][j].size == 0) {

  197.                   dv_vlc_map[i][j].vlc = dv_vlc_map[0][j].vlc |

  198.                             (dv_vlc_map[i-1][0].vlc << (dv_vlc_map[0][j].size));

  199.                   dv_vlc_map[i][j].size = dv_vlc_map[i-1][0].size +

  200.                                           dv_vlc_map[0][j].size;

  201.               }

  202.            }

  203. #else

  204.            for (j = 1; j < DV_VLC_MAP_LEV_SIZE/2; j++) {

  205.               if (dv_vlc_map[i][j].size == 0) {

  206.                   dv_vlc_map[i][j].vlc = dv_vlc_map[0][j].vlc |

  207.                             (dv_vlc_map[i-1][0].vlc << (dv_vlc_map[0][j].size));

  208.                   dv_vlc_map[i][j].size = dv_vlc_map[i-1][0].size +

  209.                                           dv_vlc_map[0][j].size;

  210.               }

  211.               dv_vlc_map[i][((uint16_t)(-j))&0x1ff].vlc =

  212.                                             dv_vlc_map[i][j].vlc | 1;

  213.               dv_vlc_map[i][((uint16_t)(-j))&0x1ff].size =

  214.                                             dv_vlc_map[i][j].size;

  215.            }

  216. #endif

  217.         }

  218.     }

  219. 

  220.     /* Generic DSP setup */

  221.     dsputil_init(&dsp, avctx);

  222.     s->get_pixels = dsp.get_pixels;

  223. 

  224.     /* 88DCT setup */

  225.     s->fdct[0] = dsp.fdct;

  226.     s->idct_put[0] = dsp.idct_put;

  227.     for (i=0; i<64; i++)

  228.        s->dv_zigzag[0][i] = dsp.idct_permutation[ff_zigzag_direct[i]];

  229. 

  230.     /* 248DCT setup */

  231.     s->fdct[1] = dsp.fdct248;

  232.     s->idct_put[1] = simple_idct248_put;  // FIXME: need to add it to DSP

  233.     if(avctx->lowres){

  234.         for (i=0; i<64; i++){

  235.             int j= ff_zigzag248_direct[i];

  236.             s->dv_zigzag[1][i] = dsp.idct_permutation[(j&7) + (j&8)*4 + (j&48)/2];

  237.         }

  238.     }else

  239.         memcpy(s->dv_zigzag[1], ff_zigzag248_direct, 64);

  240. 

  241.     /* XXX: do it only for constant case */

  242.     dv_build_unquantize_tables(s, dsp.idct_permutation);

  243. 

  244.     avctx->coded_frame = &s->picture;

  245.     s->avctx= avctx;

  246. 

  247.     return 0;

  248. }

  249. 

  250. // #define VLC_DEBUG

  251. // #define printf(...) av_log(NULL, AV_LOG_ERROR, __VA_ARGS__)

  252. 

  253. typedef struct BlockInfo {

  254.     const uint8_t *shift_table;

  255.     const uint8_t *scan_table;

  256.     const int *iweight_table;

  257.     uint8_t pos; /* position in block */

  258.     uint8_t dct_mode;

  259.     uint8_t partial_bit_count;

  260.     uint16_t partial_bit_buffer;

  261.     int shift_offset;

  262. } BlockInfo;

  263. 

  264. /* block size in bits */

  265. static const uint16_t block_sizes[6] = {

  266.     112, 112, 112, 112, 80, 80

  267. };

  268. /* bit budget for AC only in 5 MBs */

  269. static const int vs_total_ac_bits = (100 * 4 + 68*2) * 5;

  270. /* see dv_88_areas and dv_248_areas for details */

  271. static const int mb_area_start[5] = { 1, 6, 21, 43, 64 };

  272. 

  273. #ifndef ALT_BITSTREAM_READER

  274. #warning only works with ALT_BITSTREAM_READER

  275. static int re_index; //Hack to make it compile

  276. #endif

  277. 

  278. static inline int get_bits_left(GetBitContext *s)

  279. {

  280.     return s->size_in_bits - get_bits_count(s);

  281. }

  282. 

  283. static inline int get_bits_size(GetBitContext *s)

  284. {

  285.     return s->size_in_bits;

  286. }

  287. 

  288. static inline int put_bits_left(PutBitContext* s)

  289. {

  290.     return (s->buf_end - s->buf) * 8 - put_bits_count(s);

  291. }

  292. 

  293. /* decode ac coefs */

  294. static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, DCTELEM *block)

  295. {

  296.     int last_index = get_bits_size(gb);

  297.     const uint8_t *scan_table = mb->scan_table;

  298.     const uint8_t *shift_table = mb->shift_table;

  299.     const int *iweight_table = mb->iweight_table;

  300.     int pos = mb->pos;

  301.     int partial_bit_count = mb->partial_bit_count;

  302.     int level, pos1, run, vlc_len, index;

  303. 

  304.     OPEN_READER(re, gb);

  305.     UPDATE_CACHE(re, gb);

  306. 

  307.     /* if we must parse a partial vlc, we do it here */

  308.     if (partial_bit_count > 0) {

  309.         re_cache = ((unsigned)re_cache >> partial_bit_count) |

  310.                    (mb->partial_bit_buffer << (sizeof(re_cache)*8 - partial_bit_count));

  311.         re_index -= partial_bit_count;

  312.         mb->partial_bit_count = 0;

  313.     }

  314. 

  315.     /* get the AC coefficients until last_index is reached */

  316.     for(;;) {

  317. #ifdef VLC_DEBUG

  318.         printf("%2d: bits=%04x index=%d\n", pos, SHOW_UBITS(re, gb, 16), re_index);

  319. #endif

  320.         /* our own optimized GET_RL_VLC */

  321.         index = NEG_USR32(re_cache, TEX_VLC_BITS);

  322.         vlc_len = dv_rl_vlc[index].len;

  323.         if (vlc_len < 0) {

  324.             index = NEG_USR32((unsigned)re_cache << TEX_VLC_BITS, -vlc_len) + dv_rl_vlc[index].level;

  325.             vlc_len = TEX_VLC_BITS - vlc_len;

  326.         }

  327.         level = dv_rl_vlc[index].level;

  328.         run = dv_rl_vlc[index].run;

  329. 

  330.         /* gotta check if we're still within gb boundaries */

  331.         if (re_index + vlc_len > last_index) {

  332.             /* should be < 16 bits otherwise a codeword could have been parsed */

  333.             mb->partial_bit_count = last_index - re_index;

  334.             mb->partial_bit_buffer = NEG_USR32(re_cache, mb->partial_bit_count);

  335.             re_index = last_index;

  336.             break;

  337.         }

  338.         re_index += vlc_len;

  339. 

  340. #ifdef VLC_DEBUG

  341.         printf("run=%d level=%d\n", run, level);

  342. #endif

  343.         pos += run;

  344.         if (pos >= 64)

  345.             break;

  346. 

  347.         pos1 = scan_table[pos];

  348.         level <<= shift_table[pos1];

  349. 

  350.         /* unweigh, round, and shift down */

  351.         level = (level*iweight_table[pos] + (1 << (dv_iweight_bits-1))) >> dv_iweight_bits;

  352. 

  353.         block[pos1] = level;

  354. 

  355.         UPDATE_CACHE(re, gb);

  356.     }

  357.     CLOSE_READER(re, gb);

  358.     mb->pos = pos;

  359. }

  360. 

  361. static inline void bit_copy(PutBitContext *pb, GetBitContext *gb)

  362. {

  363.     int bits_left = get_bits_left(gb);

  364.     while (bits_left >= MIN_CACHE_BITS) {

  365.         put_bits(pb, MIN_CACHE_BITS, get_bits(gb, MIN_CACHE_BITS));

  366.         bits_left -= MIN_CACHE_BITS;

  367.     }

  368.     if (bits_left > 0) {

  369.         put_bits(pb, bits_left, get_bits(gb, bits_left));

  370.     }

  371. }

  372. 

  373. /* mb_x and mb_y are in units of 8 pixels */

  374. static inline void dv_decode_video_segment(DVVideoContext *s,

  375.                                            uint8_t *buf_ptr1,

  376.                                            const uint16_t *mb_pos_ptr)

  377. {

  378.     int quant, dc, dct_mode, class1, j;

  379.     int mb_index, mb_x, mb_y, v, last_index;

  380.     DCTELEM *block, *block1;

  381.     int c_offset;

  382.     uint8_t *y_ptr;

  383.     void (*idct_put)(uint8_t *dest, int line_size, DCTELEM *block);

  384.     uint8_t *buf_ptr;

  385.     PutBitContext pb, vs_pb;

  386.     GetBitContext gb;

  387.     BlockInfo mb_data[5 * 6], *mb, *mb1;

  388.     DECLARE_ALIGNED_8(DCTELEM, sblock[5*6][64]);

  389.     DECLARE_ALIGNED_8(uint8_t, mb_bit_buffer[80 + 4]); /* allow some slack */

  390.     DECLARE_ALIGNED_8(uint8_t, vs_bit_buffer[5 * 80 + 4]); /* allow some slack */

  391.     const int log2_blocksize= 3-s->avctx->lowres;

  392. 

  393.     assert((((int)mb_bit_buffer)&7)==0);

  394.     assert((((int)vs_bit_buffer)&7)==0);

  395. 

  396.     memset(sblock, 0, sizeof(sblock));

  397. 

  398.     /* pass 1 : read DC and AC coefficients in blocks */

  399.     buf_ptr = buf_ptr1;

  400.     block1 = &sblock[0][0];

  401.     mb1 = mb_data;

  402.     init_put_bits(&vs_pb, vs_bit_buffer, 5 * 80);

  403.     for(mb_index = 0; mb_index < 5; mb_index++, mb1 += 6, block1 += 6 * 64) {

  404.         /* skip header */

  405.         quant = buf_ptr[3] & 0x0f;

  406.         buf_ptr += 4;

  407.         init_put_bits(&pb, mb_bit_buffer, 80);

  408.         mb = mb1;

  409.         block = block1;

  410.         for(j = 0;j < 6; j++) {

  411.             last_index = block_sizes[j];

  412.             init_get_bits(&gb, buf_ptr, last_index);

  413. 

  414.             /* get the dc */

  415.             dc = get_sbits(&gb, 9);

  416.             dct_mode = get_bits1(&gb);

  417.             mb->dct_mode = dct_mode;

  418.             mb->scan_table = s->dv_zigzag[dct_mode];

  419.             mb->iweight_table = dct_mode ? dv_iweight_248 : dv_iweight_88;

  420.             class1 = get_bits(&gb, 2);

  421.             mb->shift_table = s->dv_idct_shift[class1 == 3][dct_mode]

  422.                 [quant + dv_quant_offset[class1]];

  423.             dc = dc << 2;

  424.             /* convert to unsigned because 128 is not added in the

  425.                standard IDCT */

  426.             dc += 1024;

  427.             block[0] = dc;

  428.             buf_ptr += last_index >> 3;

  429.             mb->pos = 0;

  430.             mb->partial_bit_count = 0;

  431. 

  432. #ifdef VLC_DEBUG

  433.             printf("MB block: %d, %d ", mb_index, j);

  434. #endif

  435.             dv_decode_ac(&gb, mb, block);

  436. 

  437.             /* write the remaining bits  in a new buffer only if the

  438.                block is finished */

  439.             if (mb->pos >= 64)

  440.                 bit_copy(&pb, &gb);

  441. 

  442.             block += 64;

  443.             mb++;

  444.         }

  445. 

  446.         /* pass 2 : we can do it just after */

  447. #ifdef VLC_DEBUG

  448.         printf("***pass 2 size=%d MB#=%d\n", put_bits_count(&pb), mb_index);

  449. #endif

  450.         block = block1;

  451.         mb = mb1;

  452.         init_get_bits(&gb, mb_bit_buffer, put_bits_count(&pb));

  453.         flush_put_bits(&pb);

  454.         for(j = 0;j < 6; j++, block += 64, mb++) {

  455.             if (mb->pos < 64 && get_bits_left(&gb) > 0) {

  456.                 dv_decode_ac(&gb, mb, block);

  457.                 /* if still not finished, no need to parse other blocks */

  458.                 if (mb->pos < 64)

  459.                     break;

  460.             }

  461.         }

  462.         /* all blocks are finished, so the extra bytes can be used at

  463.            the video segment level */

  464.         if (j >= 6)

  465.             bit_copy(&vs_pb, &gb);

  466.     }

  467. 

  468.     /* we need a pass other the whole video segment */

  469. #ifdef VLC_DEBUG

  470.     printf("***pass 3 size=%d\n", put_bits_count(&vs_pb));

  471. #endif

  472.     block = &sblock[0][0];

  473.     mb = mb_data;

  474.     init_get_bits(&gb, vs_bit_buffer, put_bits_count(&vs_pb));

  475.     flush_put_bits(&vs_pb);

  476.     for(mb_index = 0; mb_index < 5; mb_index++) {

  477.         for(j = 0;j < 6; j++) {

  478.             if (mb->pos < 64) {

  479. #ifdef VLC_DEBUG

  480.                 printf("start %d:%d\n", mb_index, j);

  481. #endif

  482.                 dv_decode_ac(&gb, mb, block);

  483.             }

  484.             if (mb->pos >= 64 && mb->pos < 127)

  485.                 av_log(NULL, AV_LOG_ERROR, "AC EOB marker is absent pos=%d\n", mb->pos);

  486.             block += 64;

  487.             mb++;

  488.         }

  489.     }

  490. 

  491.     /* compute idct and place blocks */

  492.     block = &sblock[0][0];

  493.     mb = mb_data;

  494.     for(mb_index = 0; mb_index < 5; mb_index++) {

  495.         v = *mb_pos_ptr++;

  496.         mb_x = v & 0xff;

  497.         mb_y = v >> 8;

  498.         if (s->sys->pix_fmt == PIX_FMT_YUV422P) {

  499.             y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + (mb_x>>1))<<log2_blocksize);

  500.             c_offset = ((mb_y * s->picture.linesize[1] + (mb_x >> 2))<<log2_blocksize);

  501.         } else { /* 4:1:1 or 4:2:0 */

  502.             y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x)<<log2_blocksize);

  503.             if (s->sys->pix_fmt == PIX_FMT_YUV411P)

  504.                 c_offset = ((mb_y * s->picture.linesize[1] + (mb_x >> 2))<<log2_blocksize);

  505.             else /* 4:2:0 */

  506.                 c_offset = (((mb_y >> 1) * s->picture.linesize[1] + (mb_x >> 1))<<log2_blocksize);

  507.         }

  508.         for(j = 0;j < 6; j++) {

  509.             idct_put = s->idct_put[mb->dct_mode && log2_blocksize==3];

  510.             if (s->sys->pix_fmt == PIX_FMT_YUV422P) { /* 4:2:2 */

  511.                 if (j == 0 || j == 2) {

  512.                     /* Y0 Y1 */

  513.                     idct_put(y_ptr + ((j >> 1)<<log2_blocksize),

  514.                              s->picture.linesize[0], block);

  515.                 } else if(j > 3) {

  516.                     /* Cr Cb */

  517.                     idct_put(s->picture.data[6 - j] + c_offset,

  518.                              s->picture.linesize[6 - j], block);

  519.                 }

  520.                 /* note: j=1 and j=3 are "dummy" blocks in 4:2:2 */

  521.             } else { /* 4:1:1 or 4:2:0 */

  522.                 if (j < 4) {

  523.                     if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x < (704 / 8)) {

  524.                         /* NOTE: at end of line, the macroblock is handled as 420 */

  525.                         idct_put(y_ptr + (j<<log2_blocksize), s->picture.linesize[0], block);

  526.                     } else {

  527.                         idct_put(y_ptr + (((j & 1) + (j >> 1) * s->picture.linesize[0])<<log2_blocksize),

  528.                                  s->picture.linesize[0], block);

  529.                     }

  530.                 } else {

  531.                     if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) {

  532.                         uint64_t aligned_pixels[64/8];

  533.                         uint8_t *pixels= (uint8_t*)aligned_pixels;

  534.                         uint8_t *c_ptr, *c_ptr1, *ptr, *ptr1;

  535.                         int x, y, linesize;

  536.                         /* NOTE: at end of line, the macroblock is handled as 420 */

  537.                         idct_put(pixels, 8, block);

  538.                         linesize = s->picture.linesize[6 - j];

  539.                         c_ptr = s->picture.data[6 - j] + c_offset;

  540.                         ptr = pixels;

  541.                         for(y = 0;y < (1<<log2_blocksize); y++) {

  542.                             ptr1= ptr + (1<<(log2_blocksize-1));

  543.                             c_ptr1 = c_ptr + (linesize<<log2_blocksize);

  544.                             for(x=0; x < (1<<(log2_blocksize-1)); x++){

  545.                                 c_ptr[x]= ptr[x]; c_ptr1[x]= ptr1[x];

  546.                             }

  547.                             c_ptr += linesize;

  548.                             ptr += 8;

  549.                         }

  550.                     } else {

  551.                         /* don't ask me why they inverted Cb and Cr ! */

  552.                         idct_put(s->picture.data[6 - j] + c_offset,

  553.                                  s->picture.linesize[6 - j], block);

  554.                     }

  555.                 }

  556.             }

  557.             block += 64;

  558.             mb++;

  559.         }

  560.     }

  561. }

  562. 

  563. #ifdef DV_CODEC_TINY_TARGET

  564. /* Converts run and level (where level != 0) pair into vlc, returning bit size */

  565. static always_inline int dv_rl2vlc(int run, int level, int sign, uint32_t* vlc)

  566. {

  567.     int size;

  568.     if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {

  569.         *vlc = dv_vlc_map[run][level].vlc | sign;

  570.         size = dv_vlc_map[run][level].size;

  571.     }

  572.     else {

  573.         if (level < DV_VLC_MAP_LEV_SIZE) {

  574.             *vlc = dv_vlc_map[0][level].vlc | sign;

  575.             size = dv_vlc_map[0][level].size;

  576.         } else {

  577.             *vlc = 0xfe00 | (level << 1) | sign;

  578.             size = 16;

  579.         }

  580.         if (run) {

  581.             *vlc |= ((run < 16) ? dv_vlc_map[run-1][0].vlc :

  582.                                   (0x1f80 | (run - 1))) << size;

  583.             size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;

  584.         }

  585.     }

  586. 

  587.     return size;

  588. }

  589. 

  590. static always_inline int dv_rl2vlc_size(int run, int level)

  591. {

  592.     int size;

  593. 

  594.     if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {

  595.         size = dv_vlc_map[run][level].size;

  596.     }

  597.     else {

  598.         size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16;

  599.         if (run) {

  600.             size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;

  601.         }

  602.     }

  603.     return size;

  604. }

  605. #else

  606. static always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t* vlc)

  607. {

  608.     *vlc = dv_vlc_map[run][l].vlc | sign;

  609.     return dv_vlc_map[run][l].size;

  610. }

  611. 

  612. static always_inline int dv_rl2vlc_size(int run, int l)

  613. {

  614.     return dv_vlc_map[run][l].size;

  615. }

  616. #endif

  617. 

  618. typedef struct EncBlockInfo {

  619.     int area_q[4];

  620.     int bit_size[4];

  621.     int prev[5];

  622.     int cur_ac;

  623.     int cno;

  624.     int dct_mode;

  625.     DCTELEM mb[64];

  626.     uint8_t next[64];

  627.     uint8_t sign[64];

  628.     uint8_t partial_bit_count;

  629.     uint32_t partial_bit_buffer; /* we can't use uint16_t here */

  630. } EncBlockInfo;

  631. 

  632. static always_inline PutBitContext* dv_encode_ac(EncBlockInfo* bi, PutBitContext* pb_pool,

  633.                                        PutBitContext* pb_end)

  634. {

  635.     int prev;

  636.     int bits_left;

  637.     PutBitContext* pb = pb_pool;

  638.     int size = bi->partial_bit_count;

  639.     uint32_t vlc = bi->partial_bit_buffer;

  640. 

  641.     bi->partial_bit_count = bi->partial_bit_buffer = 0;

  642.     for(;;){

  643.        /* Find suitable storage space */

  644.        for (; size > (bits_left = put_bits_left(pb)); pb++) {

  645.           if (bits_left) {

  646.               size -= bits_left;

  647.               put_bits(pb, bits_left, vlc >> size);

  648.               vlc = vlc & ((1<<size)-1);

  649.           }

  650.           if (pb + 1 >= pb_end) {

  651.               bi->partial_bit_count = size;

  652.               bi->partial_bit_buffer = vlc;

  653.               return pb;

  654.           }

  655.        }

  656. 

  657.        /* Store VLC */

  658.        put_bits(pb, size, vlc);

  659. 

  660.        if(bi->cur_ac>=64)

  661.            break;

  662. 

  663.        /* Construct the next VLC */

  664.        prev= bi->cur_ac;

  665.        bi->cur_ac = bi->next[prev];

  666.        if(bi->cur_ac < 64){

  667.            size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac], bi->sign[bi->cur_ac], &vlc);

  668.        } else {

  669.            size = 4; vlc = 6; /* End Of Block stamp */

  670.        }

  671.     }

  672.     return pb;

  673. }

  674. 

  675. static always_inline void dv_set_class_number(DCTELEM* blk, EncBlockInfo* bi,

  676.                                               const uint8_t* zigzag_scan, const int *weight, int bias)

  677. {

  678.     int i, area;

  679.     /* We offer two different methods for class number assignment: the

  680.        method suggested in SMPTE 314M Table 22, and an improved

  681.        method. The SMPTE method is very conservative; it assigns class

  682.        3 (i.e. severe quantization) to any block where the largest AC

  683.        component is greater than 36. ffmpeg's DV encoder tracks AC bit

  684.        consumption precisely, so there is no need to bias most blocks

  685.        towards strongly lossy compression. Instead, we assign class 2

  686.        to most blocks, and use class 3 only when strictly necessary

  687.        (for blocks whose largest AC component exceeds 255). */

  688. 

  689. #if 0 /* SMPTE spec method */

  690.     static const int classes[] = {12, 24, 36, 0xffff};

  691. #else /* improved ffmpeg method */

  692.     static const int classes[] = {-1, -1, 255, 0xffff};

  693. #endif

  694.     int max=classes[0];

  695.     int prev=0;

  696. 

  697.     bi->mb[0] = blk[0];

  698. 

  699.     for (area = 0; area < 4; area++) {

  700.        bi->prev[area] = prev;

  701.        bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)

  702.        for (i=mb_area_start[area]; i<mb_area_start[area+1]; i++) {

  703.           int level = blk[zigzag_scan[i]];

  704. 

  705.           if (level+15 > 30U) {

  706.               bi->sign[i] = (level>>31)&1;

  707.               /* weigh it and and shift down into range, adding for rounding */

  708.               /* the extra division by a factor of 2^4 reverses the 8x expansion of the DCT

  709.                  AND the 2x doubling of the weights */

  710.               level = (ABS(level) * weight[i] + (1<<(dv_weight_bits+3))) >> (dv_weight_bits+4);

  711.               bi->mb[i] = level;

  712.               if(level>max) max= level;

  713.               bi->bit_size[area] += dv_rl2vlc_size(i - prev  - 1, level);

  714.               bi->next[prev]= i;

  715.               prev= i;

  716.           }

  717.        }

  718.     }

  719.     bi->next[prev]= i;

  720.     for(bi->cno = 0; max > classes[bi->cno]; bi->cno++);

  721. 

  722.     bi->cno += bias;

  723. 

  724.     if (bi->cno >= 3) {

  725.         bi->cno = 3;

  726.         prev=0;

  727.         i= bi->next[prev];

  728.         for (area = 0; area < 4; area++) {

  729.             bi->prev[area] = prev;

  730.             bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)

  731.             for (; i<mb_area_start[area+1]; i= bi->next[i]) {

  732.                 bi->mb[i] >>=1;

  733. 

  734.                 if (bi->mb[i]) {

  735.                     bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]);

  736.                     bi->next[prev]= i;

  737.                     prev= i;

  738.                 }

  739.             }

  740.         }

  741.         bi->next[prev]= i;

  742.     }

  743. }

  744. 

  745. //FIXME replace this by dsputil

  746. #define SC(x, y) ((s[x] - s[y]) ^ ((s[x] - s[y]) >> 7))

  747. static always_inline int dv_guess_dct_mode(DCTELEM *blk) {

  748.     DCTELEM *s;

  749.     int score88 = 0;

  750.     int score248 = 0;

  751.     int i;

  752. 

  753.     /* Compute 8-8 score (small values give a better chance for 8-8 DCT) */

  754.     s = blk;

  755.     for(i=0; i<7; i++) {

  756.         score88 += SC(0,  8) + SC(1, 9) + SC(2, 10) + SC(3, 11) +

  757.                    SC(4, 12) + SC(5,13) + SC(6, 14) + SC(7, 15);

  758.         s += 8;

  759.     }

  760.     /* Compute 2-4-8 score (small values give a better chance for 2-4-8 DCT) */

  761.     s = blk;

  762.     for(i=0; i<6; i++) {

  763.         score248 += SC(0, 16) + SC(1,17) + SC(2, 18) + SC(3, 19) +

  764.                     SC(4, 20) + SC(5,21) + SC(6, 22) + SC(7, 23);

  765.         s += 8;

  766.     }

  767. 

  768.     return (score88 - score248 > -10);

  769. }

  770. 

  771. static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos)

  772. {

  773.     int size[5];

  774.     int i, j, k, a, prev, a2;

  775.     EncBlockInfo* b;

  776. 

  777.     size[0] = size[1] = size[2] = size[3] = size[4] = 1<<24;

  778.     do {

  779.        b = blks;

  780.        for (i=0; i<5; i++) {

  781.           if (!qnos[i])

  782.               continue;

  783. 

  784.           qnos[i]--;

  785.           size[i] = 0;

  786.           for (j=0; j<6; j++, b++) {

  787.              for (a=0; a<4; a++) {

  788.                 if (b->area_q[a] != dv_quant_shifts[qnos[i] + dv_quant_offset[b->cno]][a]) {

  789.                     b->bit_size[a] = 1; // 4 areas 4 bits for EOB :)

  790.                     b->area_q[a]++;

  791.                     prev= b->prev[a];

  792.                     assert(b->next[prev] >= mb_area_start[a+1] || b->mb[prev]);

  793.                     for (k= b->next[prev] ; k<mb_area_start[a+1]; k= b->next[k]) {

  794.                        b->mb[k] >>= 1;

  795.                        if (b->mb[k]) {

  796.                            b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);

  797.                            prev= k;

  798.                        } else {

  799.                            if(b->next[k] >= mb_area_start[a+1] && b->next[k]<64){

  800.                                 for(a2=a+1; b->next[k] >= mb_area_start[a2+1]; a2++)

  801.                                     b->prev[a2] = prev;

  802.                                 assert(a2<4);

  803.                                 assert(b->mb[b->next[k]]);

  804.                                 b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]])

  805.                                                   -dv_rl2vlc_size(b->next[k] -    k - 1, b->mb[b->next[k]]);

  806.                                 assert(b->prev[a2]==k && (a2+1 >= 4 || b->prev[a2+1]!=k));

  807.                                 b->prev[a2] = prev;

  808.                            }

  809.                            b->next[prev] = b->next[k];

  810.                        }

  811.                     }

  812.                     b->prev[a+1]= prev;

  813.                 }

  814.                 size[i] += b->bit_size[a];

  815.              }

  816.           }

  817.           if(vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4])

  818.                 return;

  819.        }

  820.     } while (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4]);

  821. 

  822. 

  823.     for(a=2; a==2 || vs_total_ac_bits < size[0]; a+=a){

  824.         b = blks;

  825.         size[0] = 5*6*4; //EOB

  826.         for (j=0; j<6*5; j++, b++) {

  827.             prev= b->prev[0];

  828.             for (k= b->next[prev]; k<64; k= b->next[k]) {

  829.                 if(b->mb[k] < a && b->mb[k] > -a){

  830.                     b->next[prev] = b->next[k];

  831.                 }else{

  832.                     size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);

  833.                     prev= k;

  834.                 }

  835.             }

  836.         }

  837.     }

  838. }

  839. 

  840. static inline void dv_encode_video_segment(DVVideoContext *s,

  841.                                            uint8_t *dif,

  842.                                            const uint16_t *mb_pos_ptr)

  843. {

  844.     int mb_index, i, j, v;

  845.     int mb_x, mb_y, c_offset, linesize;

  846.     uint8_t*  y_ptr;

  847.     uint8_t*  data;

  848.     uint8_t*  ptr;

  849.     int       do_edge_wrap;

  850.     DECLARE_ALIGNED_8(DCTELEM, block[64]);

  851.     EncBlockInfo  enc_blks[5*6];

  852.     PutBitContext pbs[5*6];

  853.     PutBitContext* pb;

  854.     EncBlockInfo* enc_blk;

  855.     int       vs_bit_size = 0;

  856.     int       qnos[5];

  857. 

  858.     assert((((int)block) & 7) == 0);

  859. 

  860.     enc_blk = &enc_blks[0];

  861.     pb = &pbs[0];

  862.     for(mb_index = 0; mb_index < 5; mb_index++) {

  863.         v = *mb_pos_ptr++;

  864.         mb_x = v & 0xff;

  865.         mb_y = v >> 8;

  866.         if (s->sys->pix_fmt == PIX_FMT_YUV422P) {

  867.             y_ptr = s->picture.data[0] + (mb_y * s->picture.linesize[0] * 8) + (mb_x * 4);

  868.         } else { /* 4:1:1 */

  869.             y_ptr = s->picture.data[0] + (mb_y * s->picture.linesize[0] * 8) + (mb_x * 8);

  870.         }

  871.         if (s->sys->pix_fmt == PIX_FMT_YUV420P) {

  872.             c_offset = (((mb_y >> 1) * s->picture.linesize[1] * 8) + ((mb_x >> 1) * 8));

  873.         } else { /* 4:2:2 or 4:1:1 */

  874.             c_offset = ((mb_y * s->picture.linesize[1] * 8) + ((mb_x >> 2) * 8));

  875.         }

  876.         do_edge_wrap = 0;

  877.         qnos[mb_index] = 15; /* No quantization */

  878.         ptr = dif + mb_index*80 + 4;

  879.         for(j = 0;j < 6; j++) {

  880.             int dummy = 0;

  881.             if (s->sys->pix_fmt == PIX_FMT_YUV422P) { /* 4:2:2 */

  882.                 if (j == 0 || j == 2) {

  883.                     /* Y0 Y1 */

  884.                     data = y_ptr + ((j>>1) * 8);

  885.                     linesize = s->picture.linesize[0];

  886.                 } else if (j > 3) {

  887.                     /* Cr Cb */

  888.                     data = s->picture.data[6 - j] + c_offset;

  889.                     linesize = s->picture.linesize[6 - j];

  890.                 } else {

  891.                     /* j=1 and j=3 are "dummy" blocks, used for AC data only */

  892.                     data = 0;

  893.                     linesize = 0;

  894.                     dummy = 1;

  895.                 }

  896.             } else { /* 4:1:1 or 4:2:0 */

  897.                 if (j < 4) {  /* Four Y blocks */

  898.                     /* NOTE: at end of line, the macroblock is handled as 420 */

  899.                     if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x < (704 / 8)) {

  900.                         data = y_ptr + (j * 8);

  901.                     } else {

  902.                         data = y_ptr + ((j & 1) * 8) + ((j >> 1) * 8 * s->picture.linesize[0]);

  903.                     }

  904.                     linesize = s->picture.linesize[0];

  905.                 } else {      /* Cr and Cb blocks */

  906.                     /* don't ask Fabrice why they inverted Cb and Cr ! */

  907.                     data = s->picture.data[6 - j] + c_offset;

  908.                     linesize = s->picture.linesize[6 - j];

  909.                     if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8))

  910.                         do_edge_wrap = 1;

  911.                 }

  912.             }

  913. 

  914.             /* Everything is set up -- now just copy data -> DCT block */

  915.             if (do_edge_wrap) {  /* Edge wrap copy: 4x16 -> 8x8 */

  916.                 uint8_t* d;

  917.                 DCTELEM *b = block;

  918.                 for (i=0;i<8;i++) {

  919.                    d = data + 8 * linesize;

  920.                    b[0] = data[0]; b[1] = data[1]; b[2] = data[2]; b[3] = data[3];

  921.                    b[4] =    d[0]; b[5] =    d[1]; b[6] =    d[2]; b[7] =    d[3];

  922.                    data += linesize;

  923.                    b += 8;

  924.                 }

  925.             } else {             /* Simple copy: 8x8 -> 8x8 */

  926.                 if (!dummy)

  927.                     s->get_pixels(block, data, linesize);

  928.             }

  929. 

  930.             if(s->avctx->flags & CODEC_FLAG_INTERLACED_DCT)

  931.                 enc_blk->dct_mode = dv_guess_dct_mode(block);

  932.             else

  933.                 enc_blk->dct_mode = 0;

  934.             enc_blk->area_q[0] = enc_blk->area_q[1] = enc_blk->area_q[2] = enc_blk->area_q[3] = 0;

  935.             enc_blk->partial_bit_count = 0;

  936.             enc_blk->partial_bit_buffer = 0;

  937.             enc_blk->cur_ac = 0;

  938. 

  939.             if (dummy) {

  940.                 /* We rely on the fact that encoding all zeros leads to an immediate EOB,

  941.                    which is precisely what the spec calls for in the "dummy" blocks. */

  942.                 memset(block, 0, sizeof(block));

  943.             } else {

  944.                 s->fdct[enc_blk->dct_mode](block);

  945.             }

  946. 

  947.             dv_set_class_number(block, enc_blk,

  948.                                 enc_blk->dct_mode ? ff_zigzag248_direct : ff_zigzag_direct,

  949.                                 enc_blk->dct_mode ? dv_weight_248 : dv_weight_88,

  950.                                 j/4);

  951. 

  952.             init_put_bits(pb, ptr, block_sizes[j]/8);

  953.             put_bits(pb, 9, (uint16_t)(((enc_blk->mb[0] >> 3) - 1024 + 2) >> 2));

  954.             put_bits(pb, 1, enc_blk->dct_mode);

  955.             put_bits(pb, 2, enc_blk->cno);

  956. 

  957.             vs_bit_size += enc_blk->bit_size[0] + enc_blk->bit_size[1] +

  958.                            enc_blk->bit_size[2] + enc_blk->bit_size[3];

  959.             ++enc_blk;

  960.             ++pb;

  961.             ptr += block_sizes[j]/8;

  962.         }

  963.     }

  964. 

  965.     if (vs_total_ac_bits < vs_bit_size)

  966.         dv_guess_qnos(&enc_blks[0], &qnos[0]);

  967. 

  968.     for (i=0; i<5; i++) {

  969.        dif[i*80 + 3] = qnos[i];

  970.     }

  971. 

  972.     /* First pass over individual cells only */

  973.     for (j=0; j<5*6; j++)

  974.        dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j+1]);

  975. 

  976.     /* Second pass over each MB space */

  977.     for (j=0; j<5*6; j+=6) {

  978.         pb= &pbs[j];

  979.         for (i=0; i<6; i++) {

  980.             if (enc_blks[i+j].partial_bit_count)

  981.                 pb=dv_encode_ac(&enc_blks[i+j], pb, &pbs[j+6]);

  982.         }

  983.     }

  984. 

  985.     /* Third and final pass over the whole vides segment space */

  986.     pb= &pbs[0];

  987.     for (j=0; j<5*6; j++) {

  988.        if (enc_blks[j].partial_bit_count)

  989.            pb=dv_encode_ac(&enc_blks[j], pb, &pbs[6*5]);

  990.        if (enc_blks[j].partial_bit_count)

  991.             av_log(NULL, AV_LOG_ERROR, "ac bitstream overflow\n");

  992.     }

  993. 

  994.     for (j=0; j<5*6; j++)

  995.        flush_put_bits(&pbs[j]);

  996. }

  997. 

  998. static int dv_decode_mt(AVCodecContext *avctx, void* sl)

  999. {

  1000.     DVVideoContext *s = avctx->priv_data;

  1001.     int slice = (size_t)sl;

  1002. 

  1003.     /* which DIF channel is this? */

  1004.     int chan = slice / (s->sys->difseg_size * 27);

  1005. 

  1006.     /* slice within the DIF channel */

  1007.     int chan_slice = slice % (s->sys->difseg_size * 27);

  1008. 

  1009.     /* byte offset of this channel's data */

  1010.     int chan_offset = chan * s->sys->difseg_size * 150 * 80;

  1011. 

  1012.     dv_decode_video_segment(s, &s->buf[((chan_slice/27)*6+(chan_slice/3)+chan_slice*5+7)*80 + chan_offset],

  1013.                             &s->sys->video_place[slice*5]);

  1014.     return 0;

  1015. }

  1016. 

  1017. static int dv_encode_mt(AVCodecContext *avctx, void* sl)

  1018. {

  1019.     DVVideoContext *s = avctx->priv_data;

  1020.     int slice = (size_t)sl;

  1021. 

  1022.     /* which DIF channel is this? */

  1023.     int chan = slice / (s->sys->difseg_size * 27);

  1024. 

  1025.     /* slice within the DIF channel */

  1026.     int chan_slice = slice % (s->sys->difseg_size * 27);

  1027. 

  1028.     /* byte offset of this channel's data */

  1029.     int chan_offset = chan * s->sys->difseg_size * 150 * 80;

  1030. 

  1031.     dv_encode_video_segment(s, &s->buf[((chan_slice/27)*6+(chan_slice/3)+chan_slice*5+7)*80 + chan_offset],

  1032.                             &s->sys->video_place[slice*5]);

  1033.     return 0;

  1034. }

  1035. 

  1036. /* NOTE: exactly one frame must be given (120000 bytes for NTSC,

  1037.    144000 bytes for PAL - or twice those for 50Mbps) */

  1038. static int dvvideo_decode_frame(AVCodecContext *avctx,

  1039.                                  void *data, int *data_size,

  1040.                                  uint8_t *buf, int buf_size)

  1041. {

  1042.     DVVideoContext *s = avctx->priv_data;

  1043. 

  1044.     s->sys = dv_frame_profile(buf);

  1045.     if (!s->sys || buf_size < s->sys->frame_size)

  1046.         return -1; /* NOTE: we only accept several full frames */

  1047. 

  1048.     if(s->picture.data[0])

  1049.         avctx->release_buffer(avctx, &s->picture);

  1050. 

  1051.     s->picture.reference = 0;

  1052.     s->picture.key_frame = 1;

  1053.     s->picture.pict_type = FF_I_TYPE;

  1054.     avctx->pix_fmt = s->sys->pix_fmt;

  1055.     avcodec_set_dimensions(avctx, s->sys->width, s->sys->height);

  1056.     if(avctx->get_buffer(avctx, &s->picture) < 0) {

  1057.         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");

  1058.         return -1;

  1059.     }

  1060.     s->picture.interlaced_frame = 1;

  1061.     s->picture.top_field_first = 0;

  1062. 

  1063.     s->buf = buf;

  1064.     avctx->execute(avctx, dv_decode_mt, (void**)&dv_anchor[0], NULL,

  1065.                    s->sys->n_difchan * s->sys->difseg_size * 27);

  1066. 

  1067.     emms_c();

  1068. 

  1069.     /* return image */

  1070.     *data_size = sizeof(AVFrame);

  1071.     *(AVFrame*)data= s->picture;

  1072. 

  1073.     return s->sys->frame_size;

  1074. }

  1075. 

  1076. static int dvvideo_encode_frame(AVCodecContext *c, uint8_t *buf, int buf_size,

  1077.                                 void *data)

  1078. {

  1079.     DVVideoContext *s = c->priv_data;

  1080. 

  1081.     s->sys = dv_codec_profile(c);

  1082.     if (!s->sys)

  1083.         return -1;

  1084.     if(buf_size < s->sys->frame_size)

  1085.         return -1;

  1086. 

  1087.     c->pix_fmt = s->sys->pix_fmt;

  1088.     s->picture = *((AVFrame *)data);

  1089.     s->picture.key_frame = 1;

  1090.     s->picture.pict_type = FF_I_TYPE;

  1091. 

  1092.     s->buf = buf;

  1093.     c->execute(c, dv_encode_mt, (void**)&dv_anchor[0], NULL,

  1094.                s->sys->n_difchan * s->sys->difseg_size * 27);

  1095. 

  1096.     emms_c();

  1097. 

  1098.     /* Fill in just enough of the header for dv_frame_profile() to

  1099.        return the correct result, so that the frame can be decoded

  1100.        correctly. The rest of the metadata is filled in by the dvvideo

  1101.        avformat. (this should probably change so that encode_frame()

  1102.        fills in ALL of the metadata - e.g. for Quicktime-wrapped DV

  1103.        streams) */

  1104. 

  1105.     /* NTSC/PAL format */

  1106.     buf[3] = s->sys->dsf ? 0x80 : 0x00;

  1107. 

  1108.     /* 25Mbps or 50Mbps */

  1109.     buf[80*5 + 48 + 3] = (s->sys->pix_fmt == PIX_FMT_YUV422P) ? 0x4 : 0x0;

  1110. 

  1111.     return s->sys->frame_size;

  1112. }

  1113. 

  1114. static int dvvideo_close(AVCodecContext *c)

  1115. {

  1116. 

  1117.     return 0;

  1118. }

  1119. 

  1120. 

  1121. #ifdef CONFIG_DVVIDEO_ENCODER

  1122. AVCodec dvvideo_encoder = {

  1123.     "dvvideo",

  1124.     CODEC_TYPE_VIDEO,

  1125.     CODEC_ID_DVVIDEO,

  1126.     sizeof(DVVideoContext),

  1127.     dvvideo_init,

  1128.     dvvideo_encode_frame,

  1129.     dvvideo_close,

  1130.     NULL,

  1131.     CODEC_CAP_DR1,

  1132.     NULL

  1133. };

  1134. #endif // CONFIG_DVVIDEO_ENCODER

  1135. 

  1136. AVCodec dvvideo_decoder = {

  1137.     "dvvideo",

  1138.     CODEC_TYPE_VIDEO,

  1139.     CODEC_ID_DVVIDEO,

  1140.     sizeof(DVVideoContext),

  1141.     dvvideo_init,

  1142.     NULL,

  1143.     dvvideo_close,

  1144.     dvvideo_decode_frame,

  1145.     CODEC_CAP_DR1,

  1146.     NULL

  1147. };