Libav
|
00001 /* 00002 * DV decoder 00003 * Copyright (c) 2002 Fabrice Bellard 00004 * Copyright (c) 2004 Roman Shaposhnik 00005 * 00006 * DV encoder 00007 * Copyright (c) 2003 Roman Shaposhnik 00008 * 00009 * 50 Mbps (DVCPRO50) support 00010 * Copyright (c) 2006 Daniel Maas <dmaas@maasdigital.com> 00011 * 00012 * 100 Mbps (DVCPRO HD) support 00013 * Initial code by Daniel Maas <dmaas@maasdigital.com> (funded by BBC R&D) 00014 * Final code by Roman Shaposhnik 00015 * 00016 * Many thanks to Dan Dennedy <dan@dennedy.org> for providing wealth 00017 * of DV technical info. 00018 * 00019 * This file is part of FFmpeg. 00020 * 00021 * FFmpeg is free software; you can redistribute it and/or 00022 * modify it under the terms of the GNU Lesser General Public 00023 * License as published by the Free Software Foundation; either 00024 * version 2.1 of the License, or (at your option) any later version. 00025 * 00026 * FFmpeg is distributed in the hope that it will be useful, 00027 * but WITHOUT ANY WARRANTY; without even the implied warranty of 00028 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 00029 * Lesser General Public License for more details. 00030 * 00031 * You should have received a copy of the GNU Lesser General Public 00032 * License along with FFmpeg; if not, write to the Free Software 00033 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 00034 */ 00035 00040 #define ALT_BITSTREAM_READER 00041 #include "avcodec.h" 00042 #include "dsputil.h" 00043 #include "get_bits.h" 00044 #include "put_bits.h" 00045 #include "simple_idct.h" 00046 #include "dvdata.h" 00047 #include "dv_tablegen.h" 00048 00049 //#undef NDEBUG 00050 //#include <assert.h> 00051 00052 typedef struct DVVideoContext { 00053 const DVprofile *sys; 00054 AVFrame picture; 00055 AVCodecContext *avctx; 00056 uint8_t *buf; 00057 00058 uint8_t dv_zigzag[2][64]; 00059 00060 void (*get_pixels)(DCTELEM *block, const uint8_t *pixels, int line_size); 00061 void (*fdct[2])(DCTELEM *block); 00062 void (*idct_put[2])(uint8_t *dest, int line_size, DCTELEM *block); 00063 me_cmp_func ildct_cmp; 00064 } DVVideoContext; 00065 00066 #define TEX_VLC_BITS 9 00067 00068 /* XXX: also include quantization */ 00069 static RL_VLC_ELEM dv_rl_vlc[1184]; 00070 00071 static inline int dv_work_pool_size(const DVprofile *d) 00072 { 00073 int size = d->n_difchan*d->difseg_size*27; 00074 if (DV_PROFILE_IS_1080i50(d)) 00075 size -= 3*27; 00076 if (DV_PROFILE_IS_720p50(d)) 00077 size -= 4*27; 00078 return size; 00079 } 00080 00081 static inline void dv_calc_mb_coordinates(const DVprofile *d, int chan, int seq, int slot, 00082 uint16_t *tbl) 00083 { 00084 static const uint8_t off[] = { 2, 6, 8, 0, 4 }; 00085 static const uint8_t shuf1[] = { 36, 18, 54, 0, 72 }; 00086 static const uint8_t shuf2[] = { 24, 12, 36, 0, 48 }; 00087 static const uint8_t shuf3[] = { 18, 9, 27, 0, 36 }; 00088 00089 static const uint8_t l_start[] = {0, 4, 9, 13, 18, 22, 27, 31, 36, 40}; 00090 static const uint8_t l_start_shuffled[] = { 9, 4, 13, 0, 18 }; 00091 00092 static const uint8_t serpent1[] = {0, 1, 2, 2, 1, 0, 00093 0, 1, 2, 2, 1, 0, 00094 0, 1, 2, 2, 1, 0, 00095 0, 1, 2, 2, 1, 0, 00096 0, 1, 2}; 00097 static const uint8_t serpent2[] = {0, 1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 0, 00098 0, 1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 0, 00099 0, 1, 2, 3, 4, 5}; 00100 00101 static const uint8_t remap[][2] = {{ 0, 0}, { 0, 0}, { 0, 0}, { 0, 0}, /* dummy */ 00102 { 0, 0}, { 0, 1}, { 0, 2}, { 0, 3}, {10, 0}, 00103 {10, 1}, {10, 2}, {10, 3}, {20, 0}, {20, 1}, 00104 {20, 2}, {20, 3}, {30, 0}, {30, 1}, {30, 2}, 00105 {30, 3}, {40, 0}, {40, 1}, {40, 2}, {40, 3}, 00106 {50, 0}, {50, 1}, {50, 2}, {50, 3}, {60, 0}, 00107 {60, 1}, {60, 2}, {60, 3}, {70, 0}, {70, 1}, 00108 {70, 2}, {70, 3}, { 0,64}, { 0,65}, { 0,66}, 00109 {10,64}, {10,65}, {10,66}, {20,64}, {20,65}, 00110 {20,66}, {30,64}, {30,65}, {30,66}, {40,64}, 00111 {40,65}, {40,66}, {50,64}, {50,65}, {50,66}, 00112 {60,64}, {60,65}, {60,66}, {70,64}, {70,65}, 00113 {70,66}, { 0,67}, {20,67}, {40,67}, {60,67}}; 00114 00115 int i, k, m; 00116 int x, y, blk; 00117 00118 for (m=0; m<5; m++) { 00119 switch (d->width) { 00120 case 1440: 00121 blk = (chan*11+seq)*27+slot; 00122 00123 if (chan == 0 && seq == 11) { 00124 x = m*27+slot; 00125 if (x<90) { 00126 y = 0; 00127 } else { 00128 x = (x - 90)*2; 00129 y = 67; 00130 } 00131 } else { 00132 i = (4*chan + blk + off[m])%11; 00133 k = (blk/11)%27; 00134 00135 x = shuf1[m] + (chan&1)*9 + k%9; 00136 y = (i*3+k/9)*2 + (chan>>1) + 1; 00137 } 00138 tbl[m] = (x<<1)|(y<<9); 00139 break; 00140 case 1280: 00141 blk = (chan*10+seq)*27+slot; 00142 00143 i = (4*chan + (seq/5) + 2*blk + off[m])%10; 00144 k = (blk/5)%27; 00145 00146 x = shuf1[m]+(chan&1)*9 + k%9; 00147 y = (i*3+k/9)*2 + (chan>>1) + 4; 00148 00149 if (x >= 80) { 00150 x = remap[y][0]+((x-80)<<(y>59)); 00151 y = remap[y][1]; 00152 } 00153 tbl[m] = (x<<1)|(y<<9); 00154 break; 00155 case 960: 00156 blk = (chan*10+seq)*27+slot; 00157 00158 i = (4*chan + (seq/5) + 2*blk + off[m])%10; 00159 k = (blk/5)%27 + (i&1)*3; 00160 00161 x = shuf2[m] + k%6 + 6*(chan&1); 00162 y = l_start[i] + k/6 + 45*(chan>>1); 00163 tbl[m] = (x<<1)|(y<<9); 00164 break; 00165 case 720: 00166 switch (d->pix_fmt) { 00167 case PIX_FMT_YUV422P: 00168 x = shuf3[m] + slot/3; 00169 y = serpent1[slot] + 00170 ((((seq + off[m]) % d->difseg_size)<<1) + chan)*3; 00171 tbl[m] = (x<<1)|(y<<8); 00172 break; 00173 case PIX_FMT_YUV420P: 00174 x = shuf3[m] + slot/3; 00175 y = serpent1[slot] + 00176 ((seq + off[m]) % d->difseg_size)*3; 00177 tbl[m] = (x<<1)|(y<<9); 00178 break; 00179 case PIX_FMT_YUV411P: 00180 i = (seq + off[m]) % d->difseg_size; 00181 k = slot + ((m==1||m==2)?3:0); 00182 00183 x = l_start_shuffled[m] + k/6; 00184 y = serpent2[k] + i*6; 00185 if (x>21) 00186 y = y*2 - i*6; 00187 tbl[m] = (x<<2)|(y<<8); 00188 break; 00189 } 00190 default: 00191 break; 00192 } 00193 } 00194 } 00195 00196 static int dv_init_dynamic_tables(const DVprofile *d) 00197 { 00198 int j,i,c,s,p; 00199 uint32_t *factor1, *factor2; 00200 const int *iweight1, *iweight2; 00201 00202 if (!d->work_chunks[dv_work_pool_size(d)-1].buf_offset) { 00203 p = i = 0; 00204 for (c=0; c<d->n_difchan; c++) { 00205 for (s=0; s<d->difseg_size; s++) { 00206 p += 6; 00207 for (j=0; j<27; j++) { 00208 p += !(j%3); 00209 if (!(DV_PROFILE_IS_1080i50(d) && c != 0 && s == 11) && 00210 !(DV_PROFILE_IS_720p50(d) && s > 9)) { 00211 dv_calc_mb_coordinates(d, c, s, j, &d->work_chunks[i].mb_coordinates[0]); 00212 d->work_chunks[i++].buf_offset = p; 00213 } 00214 p += 5; 00215 } 00216 } 00217 } 00218 } 00219 00220 if (!d->idct_factor[DV_PROFILE_IS_HD(d)?8191:5631]) { 00221 factor1 = &d->idct_factor[0]; 00222 factor2 = &d->idct_factor[DV_PROFILE_IS_HD(d)?4096:2816]; 00223 if (d->height == 720) { 00224 iweight1 = &dv_iweight_720_y[0]; 00225 iweight2 = &dv_iweight_720_c[0]; 00226 } else { 00227 iweight1 = &dv_iweight_1080_y[0]; 00228 iweight2 = &dv_iweight_1080_c[0]; 00229 } 00230 if (DV_PROFILE_IS_HD(d)) { 00231 for (c = 0; c < 4; c++) { 00232 for (s = 0; s < 16; s++) { 00233 for (i = 0; i < 64; i++) { 00234 *factor1++ = (dv100_qstep[s] << (c + 9)) * iweight1[i]; 00235 *factor2++ = (dv100_qstep[s] << (c + 9)) * iweight2[i]; 00236 } 00237 } 00238 } 00239 } else { 00240 iweight1 = &dv_iweight_88[0]; 00241 for (j = 0; j < 2; j++, iweight1 = &dv_iweight_248[0]) { 00242 for (s = 0; s < 22; s++) { 00243 for (i = c = 0; c < 4; c++) { 00244 for (; i < dv_quant_areas[c]; i++) { 00245 *factor1 = iweight1[i] << (dv_quant_shifts[s][c] + 1); 00246 *factor2++ = (*factor1++) << 1; 00247 } 00248 } 00249 } 00250 } 00251 } 00252 } 00253 00254 return 0; 00255 } 00256 00257 static av_cold int dvvideo_init(AVCodecContext *avctx) 00258 { 00259 DVVideoContext *s = avctx->priv_data; 00260 DSPContext dsp; 00261 static int done = 0; 00262 int i, j; 00263 00264 if (!done) { 00265 VLC dv_vlc; 00266 uint16_t new_dv_vlc_bits[NB_DV_VLC*2]; 00267 uint8_t new_dv_vlc_len[NB_DV_VLC*2]; 00268 uint8_t new_dv_vlc_run[NB_DV_VLC*2]; 00269 int16_t new_dv_vlc_level[NB_DV_VLC*2]; 00270 00271 done = 1; 00272 00273 /* it's faster to include sign bit in a generic VLC parsing scheme */ 00274 for (i = 0, j = 0; i < NB_DV_VLC; i++, j++) { 00275 new_dv_vlc_bits[j] = dv_vlc_bits[i]; 00276 new_dv_vlc_len[j] = dv_vlc_len[i]; 00277 new_dv_vlc_run[j] = dv_vlc_run[i]; 00278 new_dv_vlc_level[j] = dv_vlc_level[i]; 00279 00280 if (dv_vlc_level[i]) { 00281 new_dv_vlc_bits[j] <<= 1; 00282 new_dv_vlc_len[j]++; 00283 00284 j++; 00285 new_dv_vlc_bits[j] = (dv_vlc_bits[i] << 1) | 1; 00286 new_dv_vlc_len[j] = dv_vlc_len[i] + 1; 00287 new_dv_vlc_run[j] = dv_vlc_run[i]; 00288 new_dv_vlc_level[j] = -dv_vlc_level[i]; 00289 } 00290 } 00291 00292 /* NOTE: as a trick, we use the fact the no codes are unused 00293 to accelerate the parsing of partial codes */ 00294 init_vlc(&dv_vlc, TEX_VLC_BITS, j, 00295 new_dv_vlc_len, 1, 1, new_dv_vlc_bits, 2, 2, 0); 00296 assert(dv_vlc.table_size == 1184); 00297 00298 for (i = 0; i < dv_vlc.table_size; i++){ 00299 int code = dv_vlc.table[i][0]; 00300 int len = dv_vlc.table[i][1]; 00301 int level, run; 00302 00303 if (len < 0){ //more bits needed 00304 run = 0; 00305 level = code; 00306 } else { 00307 run = new_dv_vlc_run [code] + 1; 00308 level = new_dv_vlc_level[code]; 00309 } 00310 dv_rl_vlc[i].len = len; 00311 dv_rl_vlc[i].level = level; 00312 dv_rl_vlc[i].run = run; 00313 } 00314 free_vlc(&dv_vlc); 00315 00316 dv_vlc_map_tableinit(); 00317 } 00318 00319 /* Generic DSP setup */ 00320 dsputil_init(&dsp, avctx); 00321 ff_set_cmp(&dsp, dsp.ildct_cmp, avctx->ildct_cmp); 00322 s->get_pixels = dsp.get_pixels; 00323 s->ildct_cmp = dsp.ildct_cmp[5]; 00324 00325 /* 88DCT setup */ 00326 s->fdct[0] = dsp.fdct; 00327 s->idct_put[0] = dsp.idct_put; 00328 for (i = 0; i < 64; i++) 00329 s->dv_zigzag[0][i] = dsp.idct_permutation[ff_zigzag_direct[i]]; 00330 00331 /* 248DCT setup */ 00332 s->fdct[1] = dsp.fdct248; 00333 s->idct_put[1] = ff_simple_idct248_put; // FIXME: need to add it to DSP 00334 if (avctx->lowres){ 00335 for (i = 0; i < 64; i++){ 00336 int j = ff_zigzag248_direct[i]; 00337 s->dv_zigzag[1][i] = dsp.idct_permutation[(j & 7) + (j & 8) * 4 + (j & 48) / 2]; 00338 } 00339 }else 00340 memcpy(s->dv_zigzag[1], ff_zigzag248_direct, 64); 00341 00342 avctx->coded_frame = &s->picture; 00343 s->avctx = avctx; 00344 avctx->chroma_sample_location = AVCHROMA_LOC_TOPLEFT; 00345 00346 return 0; 00347 } 00348 00349 static av_cold int dvvideo_init_encoder(AVCodecContext *avctx) 00350 { 00351 if (!ff_dv_codec_profile(avctx)) { 00352 av_log(avctx, AV_LOG_ERROR, "Found no DV profile for %ix%i %s video\n", 00353 avctx->width, avctx->height, avcodec_get_pix_fmt_name(avctx->pix_fmt)); 00354 return -1; 00355 } 00356 00357 return dvvideo_init(avctx); 00358 } 00359 00360 // #define VLC_DEBUG 00361 // #define printf(...) av_log(NULL, AV_LOG_ERROR, __VA_ARGS__) 00362 00363 typedef struct BlockInfo { 00364 const uint32_t *factor_table; 00365 const uint8_t *scan_table; 00366 uint8_t pos; /* position in block */ 00367 void (*idct_put)(uint8_t *dest, int line_size, DCTELEM *block); 00368 uint8_t partial_bit_count; 00369 uint16_t partial_bit_buffer; 00370 int shift_offset; 00371 } BlockInfo; 00372 00373 /* bit budget for AC only in 5 MBs */ 00374 static const int vs_total_ac_bits = (100 * 4 + 68*2) * 5; 00375 /* see dv_88_areas and dv_248_areas for details */ 00376 static const int mb_area_start[5] = { 1, 6, 21, 43, 64 }; 00377 00378 static inline int put_bits_left(PutBitContext* s) 00379 { 00380 return (s->buf_end - s->buf) * 8 - put_bits_count(s); 00381 } 00382 00383 /* decode ac coefficients */ 00384 static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, DCTELEM *block) 00385 { 00386 int last_index = gb->size_in_bits; 00387 const uint8_t *scan_table = mb->scan_table; 00388 const uint32_t *factor_table = mb->factor_table; 00389 int pos = mb->pos; 00390 int partial_bit_count = mb->partial_bit_count; 00391 int level, run, vlc_len, index; 00392 00393 OPEN_READER(re, gb); 00394 UPDATE_CACHE(re, gb); 00395 00396 /* if we must parse a partial vlc, we do it here */ 00397 if (partial_bit_count > 0) { 00398 re_cache = ((unsigned)re_cache >> partial_bit_count) | 00399 (mb->partial_bit_buffer << (sizeof(re_cache) * 8 - partial_bit_count)); 00400 re_index -= partial_bit_count; 00401 mb->partial_bit_count = 0; 00402 } 00403 00404 /* get the AC coefficients until last_index is reached */ 00405 for (;;) { 00406 #ifdef VLC_DEBUG 00407 printf("%2d: bits=%04x index=%d\n", pos, SHOW_UBITS(re, gb, 16), re_index); 00408 #endif 00409 /* our own optimized GET_RL_VLC */ 00410 index = NEG_USR32(re_cache, TEX_VLC_BITS); 00411 vlc_len = dv_rl_vlc[index].len; 00412 if (vlc_len < 0) { 00413 index = NEG_USR32((unsigned)re_cache << TEX_VLC_BITS, -vlc_len) + dv_rl_vlc[index].level; 00414 vlc_len = TEX_VLC_BITS - vlc_len; 00415 } 00416 level = dv_rl_vlc[index].level; 00417 run = dv_rl_vlc[index].run; 00418 00419 /* gotta check if we're still within gb boundaries */ 00420 if (re_index + vlc_len > last_index) { 00421 /* should be < 16 bits otherwise a codeword could have been parsed */ 00422 mb->partial_bit_count = last_index - re_index; 00423 mb->partial_bit_buffer = NEG_USR32(re_cache, mb->partial_bit_count); 00424 re_index = last_index; 00425 break; 00426 } 00427 re_index += vlc_len; 00428 00429 #ifdef VLC_DEBUG 00430 printf("run=%d level=%d\n", run, level); 00431 #endif 00432 pos += run; 00433 if (pos >= 64) 00434 break; 00435 00436 level = (level * factor_table[pos] + (1 << (dv_iweight_bits - 1))) >> dv_iweight_bits; 00437 block[scan_table[pos]] = level; 00438 00439 UPDATE_CACHE(re, gb); 00440 } 00441 CLOSE_READER(re, gb); 00442 mb->pos = pos; 00443 } 00444 00445 static inline void bit_copy(PutBitContext *pb, GetBitContext *gb) 00446 { 00447 int bits_left = get_bits_left(gb); 00448 while (bits_left >= MIN_CACHE_BITS) { 00449 put_bits(pb, MIN_CACHE_BITS, get_bits(gb, MIN_CACHE_BITS)); 00450 bits_left -= MIN_CACHE_BITS; 00451 } 00452 if (bits_left > 0) { 00453 put_bits(pb, bits_left, get_bits(gb, bits_left)); 00454 } 00455 } 00456 00457 static inline void dv_calculate_mb_xy(DVVideoContext *s, DVwork_chunk *work_chunk, int m, int *mb_x, int *mb_y) 00458 { 00459 *mb_x = work_chunk->mb_coordinates[m] & 0xff; 00460 *mb_y = work_chunk->mb_coordinates[m] >> 8; 00461 00462 /* We work with 720p frames split in half. The odd half-frame (chan==2,3) is displaced :-( */ 00463 if (s->sys->height == 720 && !(s->buf[1]&0x0C)) { 00464 *mb_y -= (*mb_y>17)?18:-72; /* shifting the Y coordinate down by 72/2 macro blocks */ 00465 } 00466 } 00467 00468 /* mb_x and mb_y are in units of 8 pixels */ 00469 static int dv_decode_video_segment(AVCodecContext *avctx, void *arg) 00470 { 00471 DVVideoContext *s = avctx->priv_data; 00472 DVwork_chunk *work_chunk = arg; 00473 int quant, dc, dct_mode, class1, j; 00474 int mb_index, mb_x, mb_y, last_index; 00475 int y_stride, linesize; 00476 DCTELEM *block, *block1; 00477 int c_offset; 00478 uint8_t *y_ptr; 00479 const uint8_t *buf_ptr; 00480 PutBitContext pb, vs_pb; 00481 GetBitContext gb; 00482 BlockInfo mb_data[5 * DV_MAX_BPM], *mb, *mb1; 00483 LOCAL_ALIGNED_16(DCTELEM, sblock, [5*DV_MAX_BPM], [64]); 00484 LOCAL_ALIGNED_16(uint8_t, mb_bit_buffer, [80 + 4]); /* allow some slack */ 00485 LOCAL_ALIGNED_16(uint8_t, vs_bit_buffer, [5 * 80 + 4]); /* allow some slack */ 00486 const int log2_blocksize = 3-s->avctx->lowres; 00487 int is_field_mode[5]; 00488 00489 assert((((int)mb_bit_buffer) & 7) == 0); 00490 assert((((int)vs_bit_buffer) & 7) == 0); 00491 00492 memset(sblock, 0, 5*DV_MAX_BPM*sizeof(*sblock)); 00493 00494 /* pass 1 : read DC and AC coefficients in blocks */ 00495 buf_ptr = &s->buf[work_chunk->buf_offset*80]; 00496 block1 = &sblock[0][0]; 00497 mb1 = mb_data; 00498 init_put_bits(&vs_pb, vs_bit_buffer, 5 * 80); 00499 for (mb_index = 0; mb_index < 5; mb_index++, mb1 += s->sys->bpm, block1 += s->sys->bpm * 64) { 00500 /* skip header */ 00501 quant = buf_ptr[3] & 0x0f; 00502 buf_ptr += 4; 00503 init_put_bits(&pb, mb_bit_buffer, 80); 00504 mb = mb1; 00505 block = block1; 00506 is_field_mode[mb_index] = 0; 00507 for (j = 0; j < s->sys->bpm; j++) { 00508 last_index = s->sys->block_sizes[j]; 00509 init_get_bits(&gb, buf_ptr, last_index); 00510 00511 /* get the dc */ 00512 dc = get_sbits(&gb, 9); 00513 dct_mode = get_bits1(&gb); 00514 class1 = get_bits(&gb, 2); 00515 if (DV_PROFILE_IS_HD(s->sys)) { 00516 mb->idct_put = s->idct_put[0]; 00517 mb->scan_table = s->dv_zigzag[0]; 00518 mb->factor_table = &s->sys->idct_factor[(j >= 4)*4*16*64 + class1*16*64 + quant*64]; 00519 is_field_mode[mb_index] |= !j && dct_mode; 00520 } else { 00521 mb->idct_put = s->idct_put[dct_mode && log2_blocksize == 3]; 00522 mb->scan_table = s->dv_zigzag[dct_mode]; 00523 mb->factor_table = &s->sys->idct_factor[(class1 == 3)*2*22*64 + dct_mode*22*64 + 00524 (quant + dv_quant_offset[class1])*64]; 00525 } 00526 dc = dc << 2; 00527 /* convert to unsigned because 128 is not added in the 00528 standard IDCT */ 00529 dc += 1024; 00530 block[0] = dc; 00531 buf_ptr += last_index >> 3; 00532 mb->pos = 0; 00533 mb->partial_bit_count = 0; 00534 00535 #ifdef VLC_DEBUG 00536 printf("MB block: %d, %d ", mb_index, j); 00537 #endif 00538 dv_decode_ac(&gb, mb, block); 00539 00540 /* write the remaining bits in a new buffer only if the 00541 block is finished */ 00542 if (mb->pos >= 64) 00543 bit_copy(&pb, &gb); 00544 00545 block += 64; 00546 mb++; 00547 } 00548 00549 /* pass 2 : we can do it just after */ 00550 #ifdef VLC_DEBUG 00551 printf("***pass 2 size=%d MB#=%d\n", put_bits_count(&pb), mb_index); 00552 #endif 00553 block = block1; 00554 mb = mb1; 00555 init_get_bits(&gb, mb_bit_buffer, put_bits_count(&pb)); 00556 flush_put_bits(&pb); 00557 for (j = 0; j < s->sys->bpm; j++, block += 64, mb++) { 00558 if (mb->pos < 64 && get_bits_left(&gb) > 0) { 00559 dv_decode_ac(&gb, mb, block); 00560 /* if still not finished, no need to parse other blocks */ 00561 if (mb->pos < 64) 00562 break; 00563 } 00564 } 00565 /* all blocks are finished, so the extra bytes can be used at 00566 the video segment level */ 00567 if (j >= s->sys->bpm) 00568 bit_copy(&vs_pb, &gb); 00569 } 00570 00571 /* we need a pass other the whole video segment */ 00572 #ifdef VLC_DEBUG 00573 printf("***pass 3 size=%d\n", put_bits_count(&vs_pb)); 00574 #endif 00575 block = &sblock[0][0]; 00576 mb = mb_data; 00577 init_get_bits(&gb, vs_bit_buffer, put_bits_count(&vs_pb)); 00578 flush_put_bits(&vs_pb); 00579 for (mb_index = 0; mb_index < 5; mb_index++) { 00580 for (j = 0; j < s->sys->bpm; j++) { 00581 if (mb->pos < 64) { 00582 #ifdef VLC_DEBUG 00583 printf("start %d:%d\n", mb_index, j); 00584 #endif 00585 dv_decode_ac(&gb, mb, block); 00586 } 00587 if (mb->pos >= 64 && mb->pos < 127) 00588 av_log(avctx, AV_LOG_ERROR, "AC EOB marker is absent pos=%d\n", mb->pos); 00589 block += 64; 00590 mb++; 00591 } 00592 } 00593 00594 /* compute idct and place blocks */ 00595 block = &sblock[0][0]; 00596 mb = mb_data; 00597 for (mb_index = 0; mb_index < 5; mb_index++) { 00598 dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y); 00599 00600 /* idct_put'ting luminance */ 00601 if ((s->sys->pix_fmt == PIX_FMT_YUV420P) || 00602 (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) || 00603 (s->sys->height >= 720 && mb_y != 134)) { 00604 y_stride = (s->picture.linesize[0] << ((!is_field_mode[mb_index]) * log2_blocksize)); 00605 } else { 00606 y_stride = (2 << log2_blocksize); 00607 } 00608 y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x) << log2_blocksize); 00609 linesize = s->picture.linesize[0] << is_field_mode[mb_index]; 00610 mb[0] .idct_put(y_ptr , linesize, block + 0*64); 00611 if (s->sys->video_stype == 4) { /* SD 422 */ 00612 mb[2].idct_put(y_ptr + (1 << log2_blocksize) , linesize, block + 2*64); 00613 } else { 00614 mb[1].idct_put(y_ptr + (1 << log2_blocksize) , linesize, block + 1*64); 00615 mb[2].idct_put(y_ptr + y_stride, linesize, block + 2*64); 00616 mb[3].idct_put(y_ptr + (1 << log2_blocksize) + y_stride, linesize, block + 3*64); 00617 } 00618 mb += 4; 00619 block += 4*64; 00620 00621 /* idct_put'ting chrominance */ 00622 c_offset = (((mb_y >> (s->sys->pix_fmt == PIX_FMT_YUV420P)) * s->picture.linesize[1] + 00623 (mb_x >> ((s->sys->pix_fmt == PIX_FMT_YUV411P) ? 2 : 1))) << log2_blocksize); 00624 for (j = 2; j; j--) { 00625 uint8_t *c_ptr = s->picture.data[j] + c_offset; 00626 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) { 00627 uint64_t aligned_pixels[64/8]; 00628 uint8_t *pixels = (uint8_t*)aligned_pixels; 00629 uint8_t *c_ptr1, *ptr1; 00630 int x, y; 00631 mb->idct_put(pixels, 8, block); 00632 for (y = 0; y < (1 << log2_blocksize); y++, c_ptr += s->picture.linesize[j], pixels += 8) { 00633 ptr1 = pixels + (1 << (log2_blocksize - 1)); 00634 c_ptr1 = c_ptr + (s->picture.linesize[j] << log2_blocksize); 00635 for (x = 0; x < (1 << (log2_blocksize - 1)); x++) { 00636 c_ptr[x] = pixels[x]; 00637 c_ptr1[x] = ptr1[x]; 00638 } 00639 } 00640 block += 64; mb++; 00641 } else { 00642 y_stride = (mb_y == 134) ? (1 << log2_blocksize) : 00643 s->picture.linesize[j] << ((!is_field_mode[mb_index]) * log2_blocksize); 00644 linesize = s->picture.linesize[j] << is_field_mode[mb_index]; 00645 (mb++)-> idct_put(c_ptr , linesize, block); block += 64; 00646 if (s->sys->bpm == 8) { 00647 (mb++)->idct_put(c_ptr + y_stride, linesize, block); block += 64; 00648 } 00649 } 00650 } 00651 } 00652 return 0; 00653 } 00654 00655 #if CONFIG_SMALL 00656 /* Converts run and level (where level != 0) pair into vlc, returning bit size */ 00657 static av_always_inline int dv_rl2vlc(int run, int level, int sign, uint32_t* vlc) 00658 { 00659 int size; 00660 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) { 00661 *vlc = dv_vlc_map[run][level].vlc | sign; 00662 size = dv_vlc_map[run][level].size; 00663 } 00664 else { 00665 if (level < DV_VLC_MAP_LEV_SIZE) { 00666 *vlc = dv_vlc_map[0][level].vlc | sign; 00667 size = dv_vlc_map[0][level].size; 00668 } else { 00669 *vlc = 0xfe00 | (level << 1) | sign; 00670 size = 16; 00671 } 00672 if (run) { 00673 *vlc |= ((run < 16) ? dv_vlc_map[run-1][0].vlc : 00674 (0x1f80 | (run - 1))) << size; 00675 size += (run < 16) ? dv_vlc_map[run-1][0].size : 13; 00676 } 00677 } 00678 00679 return size; 00680 } 00681 00682 static av_always_inline int dv_rl2vlc_size(int run, int level) 00683 { 00684 int size; 00685 00686 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) { 00687 size = dv_vlc_map[run][level].size; 00688 } 00689 else { 00690 size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16; 00691 if (run) { 00692 size += (run < 16) ? dv_vlc_map[run-1][0].size : 13; 00693 } 00694 } 00695 return size; 00696 } 00697 #else 00698 static av_always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t* vlc) 00699 { 00700 *vlc = dv_vlc_map[run][l].vlc | sign; 00701 return dv_vlc_map[run][l].size; 00702 } 00703 00704 static av_always_inline int dv_rl2vlc_size(int run, int l) 00705 { 00706 return dv_vlc_map[run][l].size; 00707 } 00708 #endif 00709 00710 typedef struct EncBlockInfo { 00711 int area_q[4]; 00712 int bit_size[4]; 00713 int prev[5]; 00714 int cur_ac; 00715 int cno; 00716 int dct_mode; 00717 DCTELEM mb[64]; 00718 uint8_t next[64]; 00719 uint8_t sign[64]; 00720 uint8_t partial_bit_count; 00721 uint32_t partial_bit_buffer; /* we can't use uint16_t here */ 00722 } EncBlockInfo; 00723 00724 static av_always_inline PutBitContext* dv_encode_ac(EncBlockInfo* bi, 00725 PutBitContext* pb_pool, 00726 PutBitContext* pb_end) 00727 { 00728 int prev, bits_left; 00729 PutBitContext* pb = pb_pool; 00730 int size = bi->partial_bit_count; 00731 uint32_t vlc = bi->partial_bit_buffer; 00732 00733 bi->partial_bit_count = bi->partial_bit_buffer = 0; 00734 for (;;){ 00735 /* Find suitable storage space */ 00736 for (; size > (bits_left = put_bits_left(pb)); pb++) { 00737 if (bits_left) { 00738 size -= bits_left; 00739 put_bits(pb, bits_left, vlc >> size); 00740 vlc = vlc & ((1 << size) - 1); 00741 } 00742 if (pb + 1 >= pb_end) { 00743 bi->partial_bit_count = size; 00744 bi->partial_bit_buffer = vlc; 00745 return pb; 00746 } 00747 } 00748 00749 /* Store VLC */ 00750 put_bits(pb, size, vlc); 00751 00752 if (bi->cur_ac >= 64) 00753 break; 00754 00755 /* Construct the next VLC */ 00756 prev = bi->cur_ac; 00757 bi->cur_ac = bi->next[prev]; 00758 if (bi->cur_ac < 64){ 00759 size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac], bi->sign[bi->cur_ac], &vlc); 00760 } else { 00761 size = 4; vlc = 6; /* End Of Block stamp */ 00762 } 00763 } 00764 return pb; 00765 } 00766 00767 static av_always_inline int dv_guess_dct_mode(DVVideoContext *s, uint8_t *data, int linesize) { 00768 if (s->avctx->flags & CODEC_FLAG_INTERLACED_DCT) { 00769 int ps = s->ildct_cmp(NULL, data, NULL, linesize, 8) - 400; 00770 if (ps > 0) { 00771 int is = s->ildct_cmp(NULL, data , NULL, linesize<<1, 4) + 00772 s->ildct_cmp(NULL, data + linesize, NULL, linesize<<1, 4); 00773 return (ps > is); 00774 } 00775 } 00776 00777 return 0; 00778 } 00779 00780 static av_always_inline int dv_init_enc_block(EncBlockInfo* bi, uint8_t *data, int linesize, DVVideoContext *s, int bias) 00781 { 00782 const int *weight; 00783 const uint8_t* zigzag_scan; 00784 LOCAL_ALIGNED_16(DCTELEM, blk, [64]); 00785 int i, area; 00786 /* We offer two different methods for class number assignment: the 00787 method suggested in SMPTE 314M Table 22, and an improved 00788 method. The SMPTE method is very conservative; it assigns class 00789 3 (i.e. severe quantization) to any block where the largest AC 00790 component is greater than 36. FFmpeg's DV encoder tracks AC bit 00791 consumption precisely, so there is no need to bias most blocks 00792 towards strongly lossy compression. Instead, we assign class 2 00793 to most blocks, and use class 3 only when strictly necessary 00794 (for blocks whose largest AC component exceeds 255). */ 00795 00796 #if 0 /* SMPTE spec method */ 00797 static const int classes[] = {12, 24, 36, 0xffff}; 00798 #else /* improved FFmpeg method */ 00799 static const int classes[] = {-1, -1, 255, 0xffff}; 00800 #endif 00801 int max = classes[0]; 00802 int prev = 0; 00803 00804 assert((((int)blk) & 15) == 0); 00805 00806 bi->area_q[0] = bi->area_q[1] = bi->area_q[2] = bi->area_q[3] = 0; 00807 bi->partial_bit_count = 0; 00808 bi->partial_bit_buffer = 0; 00809 bi->cur_ac = 0; 00810 if (data) { 00811 bi->dct_mode = dv_guess_dct_mode(s, data, linesize); 00812 s->get_pixels(blk, data, linesize); 00813 s->fdct[bi->dct_mode](blk); 00814 } else { 00815 /* We rely on the fact that encoding all zeros leads to an immediate EOB, 00816 which is precisely what the spec calls for in the "dummy" blocks. */ 00817 memset(blk, 0, 64*sizeof(*blk)); 00818 bi->dct_mode = 0; 00819 } 00820 bi->mb[0] = blk[0]; 00821 00822 zigzag_scan = bi->dct_mode ? ff_zigzag248_direct : ff_zigzag_direct; 00823 weight = bi->dct_mode ? dv_weight_248 : dv_weight_88; 00824 00825 for (area = 0; area < 4; area++) { 00826 bi->prev[area] = prev; 00827 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :) 00828 for (i = mb_area_start[area]; i < mb_area_start[area+1]; i++) { 00829 int level = blk[zigzag_scan[i]]; 00830 00831 if (level + 15 > 30U) { 00832 bi->sign[i] = (level >> 31) & 1; 00833 /* weigh it and and shift down into range, adding for rounding */ 00834 /* the extra division by a factor of 2^4 reverses the 8x expansion of the DCT 00835 AND the 2x doubling of the weights */ 00836 level = (FFABS(level) * weight[i] + (1 << (dv_weight_bits+3))) >> (dv_weight_bits+4); 00837 bi->mb[i] = level; 00838 if (level > max) 00839 max = level; 00840 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, level); 00841 bi->next[prev]= i; 00842 prev = i; 00843 } 00844 } 00845 } 00846 bi->next[prev]= i; 00847 for (bi->cno = 0; max > classes[bi->cno]; bi->cno++); 00848 00849 bi->cno += bias; 00850 00851 if (bi->cno >= 3) { 00852 bi->cno = 3; 00853 prev = 0; 00854 i = bi->next[prev]; 00855 for (area = 0; area < 4; area++) { 00856 bi->prev[area] = prev; 00857 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :) 00858 for (; i < mb_area_start[area+1]; i = bi->next[i]) { 00859 bi->mb[i] >>= 1; 00860 00861 if (bi->mb[i]) { 00862 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]); 00863 bi->next[prev]= i; 00864 prev = i; 00865 } 00866 } 00867 } 00868 bi->next[prev]= i; 00869 } 00870 00871 return bi->bit_size[0] + bi->bit_size[1] + bi->bit_size[2] + bi->bit_size[3]; 00872 } 00873 00874 static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos) 00875 { 00876 int size[5]; 00877 int i, j, k, a, prev, a2; 00878 EncBlockInfo* b; 00879 00880 size[0] = size[1] = size[2] = size[3] = size[4] = 1 << 24; 00881 do { 00882 b = blks; 00883 for (i = 0; i < 5; i++) { 00884 if (!qnos[i]) 00885 continue; 00886 00887 qnos[i]--; 00888 size[i] = 0; 00889 for (j = 0; j < 6; j++, b++) { 00890 for (a = 0; a < 4; a++) { 00891 if (b->area_q[a] != dv_quant_shifts[qnos[i] + dv_quant_offset[b->cno]][a]) { 00892 b->bit_size[a] = 1; // 4 areas 4 bits for EOB :) 00893 b->area_q[a]++; 00894 prev = b->prev[a]; 00895 assert(b->next[prev] >= mb_area_start[a+1] || b->mb[prev]); 00896 for (k = b->next[prev] ; k < mb_area_start[a+1]; k = b->next[k]) { 00897 b->mb[k] >>= 1; 00898 if (b->mb[k]) { 00899 b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]); 00900 prev = k; 00901 } else { 00902 if (b->next[k] >= mb_area_start[a+1] && b->next[k]<64){ 00903 for (a2 = a + 1; b->next[k] >= mb_area_start[a2+1]; a2++) 00904 b->prev[a2] = prev; 00905 assert(a2 < 4); 00906 assert(b->mb[b->next[k]]); 00907 b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]]) 00908 -dv_rl2vlc_size(b->next[k] - k - 1, b->mb[b->next[k]]); 00909 assert(b->prev[a2] == k && (a2 + 1 >= 4 || b->prev[a2+1] != k)); 00910 b->prev[a2] = prev; 00911 } 00912 b->next[prev] = b->next[k]; 00913 } 00914 } 00915 b->prev[a+1]= prev; 00916 } 00917 size[i] += b->bit_size[a]; 00918 } 00919 } 00920 if (vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4]) 00921 return; 00922 } 00923 } while (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4]); 00924 00925 00926 for (a = 2; a == 2 || vs_total_ac_bits < size[0]; a += a){ 00927 b = blks; 00928 size[0] = 5 * 6 * 4; //EOB 00929 for (j = 0; j < 6 *5; j++, b++) { 00930 prev = b->prev[0]; 00931 for (k = b->next[prev]; k < 64; k = b->next[k]) { 00932 if (b->mb[k] < a && b->mb[k] > -a){ 00933 b->next[prev] = b->next[k]; 00934 }else{ 00935 size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]); 00936 prev = k; 00937 } 00938 } 00939 } 00940 } 00941 } 00942 00943 static int dv_encode_video_segment(AVCodecContext *avctx, void *arg) 00944 { 00945 DVVideoContext *s = avctx->priv_data; 00946 DVwork_chunk *work_chunk = arg; 00947 int mb_index, i, j; 00948 int mb_x, mb_y, c_offset, linesize, y_stride; 00949 uint8_t* y_ptr; 00950 uint8_t* dif; 00951 uint8_t scratch[64]; 00952 EncBlockInfo enc_blks[5*DV_MAX_BPM]; 00953 PutBitContext pbs[5*DV_MAX_BPM]; 00954 PutBitContext* pb; 00955 EncBlockInfo* enc_blk; 00956 int vs_bit_size = 0; 00957 int qnos[5] = {15, 15, 15, 15, 15}; /* No quantization */ 00958 int* qnosp = &qnos[0]; 00959 00960 dif = &s->buf[work_chunk->buf_offset*80]; 00961 enc_blk = &enc_blks[0]; 00962 for (mb_index = 0; mb_index < 5; mb_index++) { 00963 dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y); 00964 00965 /* initializing luminance blocks */ 00966 if ((s->sys->pix_fmt == PIX_FMT_YUV420P) || 00967 (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) || 00968 (s->sys->height >= 720 && mb_y != 134)) { 00969 y_stride = s->picture.linesize[0] << 3; 00970 } else { 00971 y_stride = 16; 00972 } 00973 y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x) << 3); 00974 linesize = s->picture.linesize[0]; 00975 00976 if (s->sys->video_stype == 4) { /* SD 422 */ 00977 vs_bit_size += 00978 dv_init_enc_block(enc_blk+0, y_ptr , linesize, s, 0) + 00979 dv_init_enc_block(enc_blk+1, NULL , linesize, s, 0) + 00980 dv_init_enc_block(enc_blk+2, y_ptr + 8 , linesize, s, 0) + 00981 dv_init_enc_block(enc_blk+3, NULL , linesize, s, 0); 00982 } else { 00983 vs_bit_size += 00984 dv_init_enc_block(enc_blk+0, y_ptr , linesize, s, 0) + 00985 dv_init_enc_block(enc_blk+1, y_ptr + 8 , linesize, s, 0) + 00986 dv_init_enc_block(enc_blk+2, y_ptr + y_stride, linesize, s, 0) + 00987 dv_init_enc_block(enc_blk+3, y_ptr + 8 + y_stride, linesize, s, 0); 00988 } 00989 enc_blk += 4; 00990 00991 /* initializing chrominance blocks */ 00992 c_offset = (((mb_y >> (s->sys->pix_fmt == PIX_FMT_YUV420P)) * s->picture.linesize[1] + 00993 (mb_x >> ((s->sys->pix_fmt == PIX_FMT_YUV411P) ? 2 : 1))) << 3); 00994 for (j = 2; j; j--) { 00995 uint8_t *c_ptr = s->picture.data[j] + c_offset; 00996 linesize = s->picture.linesize[j]; 00997 y_stride = (mb_y == 134) ? 8 : (s->picture.linesize[j] << 3); 00998 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) { 00999 uint8_t* d; 01000 uint8_t* b = scratch; 01001 for (i = 0; i < 8; i++) { 01002 d = c_ptr + (linesize << 3); 01003 b[0] = c_ptr[0]; b[1] = c_ptr[1]; b[2] = c_ptr[2]; b[3] = c_ptr[3]; 01004 b[4] = d[0]; b[5] = d[1]; b[6] = d[2]; b[7] = d[3]; 01005 c_ptr += linesize; 01006 b += 8; 01007 } 01008 c_ptr = scratch; 01009 linesize = 8; 01010 } 01011 01012 vs_bit_size += dv_init_enc_block( enc_blk++, c_ptr , linesize, s, 1); 01013 if (s->sys->bpm == 8) { 01014 vs_bit_size += dv_init_enc_block(enc_blk++, c_ptr + y_stride, linesize, s, 1); 01015 } 01016 } 01017 } 01018 01019 if (vs_total_ac_bits < vs_bit_size) 01020 dv_guess_qnos(&enc_blks[0], qnosp); 01021 01022 /* DIF encoding process */ 01023 for (j=0; j<5*s->sys->bpm;) { 01024 int start_mb = j; 01025 01026 dif[3] = *qnosp++; 01027 dif += 4; 01028 01029 /* First pass over individual cells only */ 01030 for (i=0; i<s->sys->bpm; i++, j++) { 01031 int sz = s->sys->block_sizes[i]>>3; 01032 01033 init_put_bits(&pbs[j], dif, sz); 01034 put_sbits(&pbs[j], 9, ((enc_blks[j].mb[0] >> 3) - 1024 + 2) >> 2); 01035 put_bits(&pbs[j], 1, enc_blks[j].dct_mode); 01036 put_bits(&pbs[j], 2, enc_blks[j].cno); 01037 01038 dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j+1]); 01039 dif += sz; 01040 } 01041 01042 /* Second pass over each MB space */ 01043 pb = &pbs[start_mb]; 01044 for (i=0; i<s->sys->bpm; i++) { 01045 if (enc_blks[start_mb+i].partial_bit_count) 01046 pb = dv_encode_ac(&enc_blks[start_mb+i], pb, &pbs[start_mb+s->sys->bpm]); 01047 } 01048 } 01049 01050 /* Third and final pass over the whole video segment space */ 01051 pb = &pbs[0]; 01052 for (j=0; j<5*s->sys->bpm; j++) { 01053 if (enc_blks[j].partial_bit_count) 01054 pb = dv_encode_ac(&enc_blks[j], pb, &pbs[s->sys->bpm*5]); 01055 if (enc_blks[j].partial_bit_count) 01056 av_log(avctx, AV_LOG_ERROR, "ac bitstream overflow\n"); 01057 } 01058 01059 for (j=0; j<5*s->sys->bpm; j++) { 01060 int pos; 01061 int size = pbs[j].size_in_bits >> 3; 01062 flush_put_bits(&pbs[j]); 01063 pos = put_bits_count(&pbs[j]) >> 3; 01064 if (pos > size) { 01065 av_log(avctx, AV_LOG_ERROR, "bitstream written beyond buffer size\n"); 01066 return -1; 01067 } 01068 memset(pbs[j].buf + pos, 0xff, size - pos); 01069 } 01070 01071 return 0; 01072 } 01073 01074 #if CONFIG_DVVIDEO_DECODER 01075 /* NOTE: exactly one frame must be given (120000 bytes for NTSC, 01076 144000 bytes for PAL - or twice those for 50Mbps) */ 01077 static int dvvideo_decode_frame(AVCodecContext *avctx, 01078 void *data, int *data_size, 01079 AVPacket *avpkt) 01080 { 01081 const uint8_t *buf = avpkt->data; 01082 int buf_size = avpkt->size; 01083 DVVideoContext *s = avctx->priv_data; 01084 01085 s->sys = ff_dv_frame_profile(s->sys, buf, buf_size); 01086 if (!s->sys || buf_size < s->sys->frame_size || dv_init_dynamic_tables(s->sys)) { 01087 av_log(avctx, AV_LOG_ERROR, "could not find dv frame profile\n"); 01088 return -1; /* NOTE: we only accept several full frames */ 01089 } 01090 01091 if (s->picture.data[0]) 01092 avctx->release_buffer(avctx, &s->picture); 01093 01094 s->picture.reference = 0; 01095 s->picture.key_frame = 1; 01096 s->picture.pict_type = FF_I_TYPE; 01097 avctx->pix_fmt = s->sys->pix_fmt; 01098 avctx->time_base = s->sys->time_base; 01099 avcodec_set_dimensions(avctx, s->sys->width, s->sys->height); 01100 if (avctx->get_buffer(avctx, &s->picture) < 0) { 01101 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n"); 01102 return -1; 01103 } 01104 s->picture.interlaced_frame = 1; 01105 s->picture.top_field_first = 0; 01106 01107 s->buf = buf; 01108 avctx->execute(avctx, dv_decode_video_segment, s->sys->work_chunks, NULL, 01109 dv_work_pool_size(s->sys), sizeof(DVwork_chunk)); 01110 01111 emms_c(); 01112 01113 /* return image */ 01114 *data_size = sizeof(AVFrame); 01115 *(AVFrame*)data = s->picture; 01116 01117 return s->sys->frame_size; 01118 } 01119 #endif /* CONFIG_DVVIDEO_DECODER */ 01120 01121 01122 static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c, 01123 uint8_t* buf) 01124 { 01125 /* 01126 * Here's what SMPTE314M says about these two: 01127 * (page 6) APTn, AP1n, AP2n, AP3n: These data shall be identical 01128 * as track application IDs (APTn = 001, AP1n = 01129 * 001, AP2n = 001, AP3n = 001), if the source signal 01130 * comes from a digital VCR. If the signal source is 01131 * unknown, all bits for these data shall be set to 1. 01132 * (page 12) STYPE: STYPE defines a signal type of video signal 01133 * 00000b = 4:1:1 compression 01134 * 00100b = 4:2:2 compression 01135 * XXXXXX = Reserved 01136 * Now, I've got two problems with these statements: 01137 * 1. it looks like APT == 111b should be a safe bet, but it isn't. 01138 * It seems that for PAL as defined in IEC 61834 we have to set 01139 * APT to 000 and for SMPTE314M to 001. 01140 * 2. It is not at all clear what STYPE is used for 4:2:0 PAL 01141 * compression scheme (if any). 01142 */ 01143 int apt = (c->sys->pix_fmt == PIX_FMT_YUV420P ? 0 : 1); 01144 01145 uint8_t aspect = 0; 01146 if ((int)(av_q2d(c->avctx->sample_aspect_ratio) * c->avctx->width / c->avctx->height * 10) >= 17) /* 16:9 */ 01147 aspect = 0x02; 01148 01149 buf[0] = (uint8_t)pack_id; 01150 switch (pack_id) { 01151 case dv_header525: /* I can't imagine why these two weren't defined as real */ 01152 case dv_header625: /* packs in SMPTE314M -- they definitely look like ones */ 01153 buf[1] = 0xf8 | /* reserved -- always 1 */ 01154 (apt & 0x07); /* APT: Track application ID */ 01155 buf[2] = (0 << 7) | /* TF1: audio data is 0 - valid; 1 - invalid */ 01156 (0x0f << 3) | /* reserved -- always 1 */ 01157 (apt & 0x07); /* AP1: Audio application ID */ 01158 buf[3] = (0 << 7) | /* TF2: video data is 0 - valid; 1 - invalid */ 01159 (0x0f << 3) | /* reserved -- always 1 */ 01160 (apt & 0x07); /* AP2: Video application ID */ 01161 buf[4] = (0 << 7) | /* TF3: subcode(SSYB) is 0 - valid; 1 - invalid */ 01162 (0x0f << 3) | /* reserved -- always 1 */ 01163 (apt & 0x07); /* AP3: Subcode application ID */ 01164 break; 01165 case dv_video_source: 01166 buf[1] = 0xff; /* reserved -- always 1 */ 01167 buf[2] = (1 << 7) | /* B/W: 0 - b/w, 1 - color */ 01168 (1 << 6) | /* following CLF is valid - 0, invalid - 1 */ 01169 (3 << 4) | /* CLF: color frames ID (see ITU-R BT.470-4) */ 01170 0xf; /* reserved -- always 1 */ 01171 buf[3] = (3 << 6) | /* reserved -- always 1 */ 01172 (c->sys->dsf << 5) | /* system: 60fields/50fields */ 01173 c->sys->video_stype; /* signal type video compression */ 01174 buf[4] = 0xff; /* VISC: 0xff -- no information */ 01175 break; 01176 case dv_video_control: 01177 buf[1] = (0 << 6) | /* Copy generation management (CGMS) 0 -- free */ 01178 0x3f; /* reserved -- always 1 */ 01179 buf[2] = 0xc8 | /* reserved -- always b11001xxx */ 01180 aspect; 01181 buf[3] = (1 << 7) | /* frame/field flag 1 -- frame, 0 -- field */ 01182 (1 << 6) | /* first/second field flag 0 -- field 2, 1 -- field 1 */ 01183 (1 << 5) | /* frame change flag 0 -- same picture as before, 1 -- different */ 01184 (1 << 4) | /* 1 - interlaced, 0 - noninterlaced */ 01185 0xc; /* reserved -- always b1100 */ 01186 buf[4] = 0xff; /* reserved -- always 1 */ 01187 break; 01188 default: 01189 buf[1] = buf[2] = buf[3] = buf[4] = 0xff; 01190 } 01191 return 5; 01192 } 01193 01194 #if CONFIG_DVVIDEO_ENCODER 01195 static void dv_format_frame(DVVideoContext* c, uint8_t* buf) 01196 { 01197 int chan, i, j, k; 01198 01199 for (chan = 0; chan < c->sys->n_difchan; chan++) { 01200 for (i = 0; i < c->sys->difseg_size; i++) { 01201 memset(buf, 0xff, 80 * 6); /* first 6 DIF blocks are for control data */ 01202 01203 /* DV header: 1DIF */ 01204 buf += dv_write_dif_id(dv_sect_header, chan, i, 0, buf); 01205 buf += dv_write_pack((c->sys->dsf ? dv_header625 : dv_header525), c, buf); 01206 buf += 72; /* unused bytes */ 01207 01208 /* DV subcode: 2DIFs */ 01209 for (j = 0; j < 2; j++) { 01210 buf += dv_write_dif_id(dv_sect_subcode, chan, i, j, buf); 01211 for (k = 0; k < 6; k++) 01212 buf += dv_write_ssyb_id(k, (i < c->sys->difseg_size/2), buf) + 5; 01213 buf += 29; /* unused bytes */ 01214 } 01215 01216 /* DV VAUX: 3DIFS */ 01217 for (j = 0; j < 3; j++) { 01218 buf += dv_write_dif_id(dv_sect_vaux, chan, i, j, buf); 01219 buf += dv_write_pack(dv_video_source, c, buf); 01220 buf += dv_write_pack(dv_video_control, c, buf); 01221 buf += 7*5; 01222 buf += dv_write_pack(dv_video_source, c, buf); 01223 buf += dv_write_pack(dv_video_control, c, buf); 01224 buf += 4*5 + 2; /* unused bytes */ 01225 } 01226 01227 /* DV Audio/Video: 135 Video DIFs + 9 Audio DIFs */ 01228 for (j = 0; j < 135; j++) { 01229 if (j%15 == 0) { 01230 memset(buf, 0xff, 80); 01231 buf += dv_write_dif_id(dv_sect_audio, chan, i, j/15, buf); 01232 buf += 77; /* audio control & shuffled PCM audio */ 01233 } 01234 buf += dv_write_dif_id(dv_sect_video, chan, i, j, buf); 01235 buf += 77; /* 1 video macroblock: 1 bytes control 01236 4 * 14 bytes Y 8x8 data 01237 10 bytes Cr 8x8 data 01238 10 bytes Cb 8x8 data */ 01239 } 01240 } 01241 } 01242 } 01243 01244 01245 static int dvvideo_encode_frame(AVCodecContext *c, uint8_t *buf, int buf_size, 01246 void *data) 01247 { 01248 DVVideoContext *s = c->priv_data; 01249 01250 s->sys = ff_dv_codec_profile(c); 01251 if (!s->sys || buf_size < s->sys->frame_size || dv_init_dynamic_tables(s->sys)) 01252 return -1; 01253 01254 c->pix_fmt = s->sys->pix_fmt; 01255 s->picture = *((AVFrame *)data); 01256 s->picture.key_frame = 1; 01257 s->picture.pict_type = FF_I_TYPE; 01258 01259 s->buf = buf; 01260 c->execute(c, dv_encode_video_segment, s->sys->work_chunks, NULL, 01261 dv_work_pool_size(s->sys), sizeof(DVwork_chunk)); 01262 01263 emms_c(); 01264 01265 dv_format_frame(s, buf); 01266 01267 return s->sys->frame_size; 01268 } 01269 #endif 01270 01271 static int dvvideo_close(AVCodecContext *c) 01272 { 01273 DVVideoContext *s = c->priv_data; 01274 01275 if (s->picture.data[0]) 01276 c->release_buffer(c, &s->picture); 01277 01278 return 0; 01279 } 01280 01281 01282 #if CONFIG_DVVIDEO_ENCODER 01283 AVCodec dvvideo_encoder = { 01284 "dvvideo", 01285 AVMEDIA_TYPE_VIDEO, 01286 CODEC_ID_DVVIDEO, 01287 sizeof(DVVideoContext), 01288 dvvideo_init_encoder, 01289 dvvideo_encode_frame, 01290 .pix_fmts = (const enum PixelFormat[]) {PIX_FMT_YUV411P, PIX_FMT_YUV422P, PIX_FMT_YUV420P, PIX_FMT_NONE}, 01291 .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"), 01292 }; 01293 #endif // CONFIG_DVVIDEO_ENCODER 01294 01295 #if CONFIG_DVVIDEO_DECODER 01296 AVCodec dvvideo_decoder = { 01297 "dvvideo", 01298 AVMEDIA_TYPE_VIDEO, 01299 CODEC_ID_DVVIDEO, 01300 sizeof(DVVideoContext), 01301 dvvideo_init, 01302 NULL, 01303 dvvideo_close, 01304 dvvideo_decode_frame, 01305 CODEC_CAP_DR1, 01306 NULL, 01307 .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"), 01308 }; 01309 #endif