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