Skip to content

F
ffmpeg.wasm-core
Commit f94036f1 authored by Diego Biurrun's avatar Diego Biurrun
Browse files
Options

prettyprinting cosmetics 

Originally committed as revision 15682 to svn://svn.ffmpeg.org/ffmpeg/trunk
parent 75f2c209
Hide whitespace changes
Inline Side-by-side
Showing with 389 additions and 378 deletions
libavcodec/dv.c
View file @ f94036f1
...@@ -48,12 +48,12 @@ ...@@ -48,12 +48,12 @@
//#include <assert.h> //#include <assert.h>
typedef struct DVVideoContext { typedef struct DVVideoContext {
const DVprofile* sys; const DVprofile *sys;
AVFrame picture; AVFrame picture;
AVCodecContext *avctx; AVCodecContext *avctx;
uint8_t *buf; uint8_t *buf;
uint8_t dv_zigzag[2][64]; uint8_t dv_zigzag[2][64];
uint32_t dv_idct_factor[2][2][22][64]; uint32_t dv_idct_factor[2][2][22][64];
uint32_t dv100_idct_factor[4][4][16][64]; uint32_t dv100_idct_factor[4][4][16][64];
...@@ -94,29 +94,29 @@ static void dv_build_unquantize_tables(DVVideoContext *s, uint8_t* perm) ...@@ -94,29 +94,29 @@ static void dv_build_unquantize_tables(DVVideoContext *s, uint8_t* perm)
int i, q, a; int i, q, a;
/* NOTE: max left shift is 6 */ /* NOTE: max left shift is 6 */
for(q = 0; q < 22; q++) { for (q = 0; q < 22; q++) {
/* 88DCT */ /* 88DCT */
i=1; i = 1;
for(a = 0; a<4; a++) { for (a = 0; a < 4; a++) {
for(; i < dv_quant_areas[a]; i++) { for (; i < dv_quant_areas[a]; i++) {
/* 88 table */ /* 88 table */
s->dv_idct_factor[0][0][q][i] = dv_iweight_88[i]<<(dv_quant_shifts[q][a] + 1); s->dv_idct_factor[0][0][q][i] = dv_iweight_88[i] << (dv_quant_shifts[q][a] + 1);
s->dv_idct_factor[1][0][q][i] = s->dv_idct_factor[0][0][q][i]<<1; s->dv_idct_factor[1][0][q][i] = s->dv_idct_factor[0][0][q][i] << 1;
/* 248 table */ /* 248 table */
s->dv_idct_factor[0][1][q][i] = dv_iweight_248[i]<<(dv_quant_shifts[q][a] + 1); s->dv_idct_factor[0][1][q][i] = dv_iweight_248[i] << (dv_quant_shifts[q][a] + 1);
s->dv_idct_factor[1][1][q][i] = s->dv_idct_factor[0][1][q][i]<<1; s->dv_idct_factor[1][1][q][i] = s->dv_idct_factor[0][1][q][i] << 1;
} }
} }
} }
for(a = 0; a < 4; a++) { for (a = 0; a < 4; a++) {
for(q = 0; q < 16; q++) { for (q = 0; q < 16; q++) {
for(i = 1; i < 64; i++) { for (i = 1; i < 64; i++) {
s->dv100_idct_factor[0][a][q][i]= (dv100_qstep[q]<<(a+9))*dv_iweight_1080_y[i]; s->dv100_idct_factor[0][a][q][i] = (dv100_qstep[q] << (a + 9)) * dv_iweight_1080_y[i];
s->dv100_idct_factor[1][a][q][i]= (dv100_qstep[q]<<(a+9))*dv_iweight_1080_c[i]; s->dv100_idct_factor[1][a][q][i] = (dv100_qstep[q] << (a + 9)) * dv_iweight_1080_c[i];
s->dv100_idct_factor[2][a][q][i]= (dv100_qstep[q]<<(a+9))*dv_iweight_720_y[i]; s->dv100_idct_factor[2][a][q][i] = (dv100_qstep[q] << (a + 9)) * dv_iweight_720_y[i];
s->dv100_idct_factor[3][a][q][i]= (dv100_qstep[q]<<(a+9))*dv_iweight_720_c[i]; s->dv100_idct_factor[3][a][q][i] = (dv100_qstep[q] << (a + 9)) * dv_iweight_720_c[i];
} }
} }
} }
...@@ -126,27 +126,27 @@ static av_cold int dvvideo_init(AVCodecContext *avctx) ...@@ -126,27 +126,27 @@ static av_cold int dvvideo_init(AVCodecContext *avctx)
{ {
DVVideoContext *s = avctx->priv_data; DVVideoContext *s = avctx->priv_data;
DSPContext dsp; DSPContext dsp;
static int done=0; static int done = 0;
int i, j; int i, j;
if (!done) { if (!done) {
VLC dv_vlc; VLC dv_vlc;
uint16_t new_dv_vlc_bits[NB_DV_VLC*2]; uint16_t new_dv_vlc_bits[NB_DV_VLC*2];
uint8_t new_dv_vlc_len[NB_DV_VLC*2]; uint8_t new_dv_vlc_len[NB_DV_VLC*2];
uint8_t new_dv_vlc_run[NB_DV_VLC*2]; uint8_t new_dv_vlc_run[NB_DV_VLC*2];
int16_t new_dv_vlc_level[NB_DV_VLC*2]; int16_t new_dv_vlc_level[NB_DV_VLC*2];
done = 1; done = 1;
/* dv_anchor lets each thread know its ID */ /* dv_anchor lets each thread know its ID */
for (i=0; i<DV_ANCHOR_SIZE; i++) for (i = 0; i < DV_ANCHOR_SIZE; i++)
dv_anchor[i] = (void*)(size_t)i; dv_anchor[i] = (void*)(size_t)i;
/* it's faster to include sign bit in a generic VLC parsing scheme */ /* it's faster to include sign bit in a generic VLC parsing scheme */
for (i=0, j=0; i<NB_DV_VLC; i++, j++) { for (i = 0, j = 0; i < NB_DV_VLC; i++, j++) {
new_dv_vlc_bits[j] = dv_vlc_bits[i]; new_dv_vlc_bits[j] = dv_vlc_bits[i];
new_dv_vlc_len[j] = dv_vlc_len[i]; new_dv_vlc_len[j] = dv_vlc_len[i];
new_dv_vlc_run[j] = dv_vlc_run[i]; new_dv_vlc_run[j] = dv_vlc_run[i];
new_dv_vlc_level[j] = dv_vlc_level[i]; new_dv_vlc_level[j] = dv_vlc_level[i];
if (dv_vlc_level[i]) { if (dv_vlc_level[i]) {
...@@ -154,9 +154,9 @@ static av_cold int dvvideo_init(AVCodecContext *avctx) ...@@ -154,9 +154,9 @@ static av_cold int dvvideo_init(AVCodecContext *avctx)
new_dv_vlc_len[j]++; new_dv_vlc_len[j]++;
j++; j++;
new_dv_vlc_bits[j] = (dv_vlc_bits[i] << 1) | 1; new_dv_vlc_bits[j] = (dv_vlc_bits[i] << 1) | 1;
new_dv_vlc_len[j] = dv_vlc_len[i] + 1; new_dv_vlc_len[j] = dv_vlc_len[i] + 1;
new_dv_vlc_run[j] = dv_vlc_run[i]; new_dv_vlc_run[j] = dv_vlc_run[i];
new_dv_vlc_level[j] = -dv_vlc_level[i]; new_dv_vlc_level[j] = -dv_vlc_level[i];
} }
} }
...@@ -167,21 +167,21 @@ static av_cold int dvvideo_init(AVCodecContext *avctx) ...@@ -167,21 +167,21 @@ static av_cold int dvvideo_init(AVCodecContext *avctx)
new_dv_vlc_len, 1, 1, new_dv_vlc_bits, 2, 2, 0); new_dv_vlc_len, 1, 1, new_dv_vlc_bits, 2, 2, 0);
assert(dv_vlc.table_size == 1184); assert(dv_vlc.table_size == 1184);
for(i = 0; i < dv_vlc.table_size; i++){ for (i = 0; i < dv_vlc.table_size; i++){
int code= dv_vlc.table[i][0]; int code = dv_vlc.table[i][0];
int len = dv_vlc.table[i][1]; int len = dv_vlc.table[i][1];
int level, run; int level, run;
if(len<0){ //more bits needed if (len < 0){ //more bits needed
run= 0; run = 0;
level= code; level = code;
} else { } else {
run= new_dv_vlc_run[code] + 1; run = new_dv_vlc_run [code] + 1;
level= new_dv_vlc_level[code]; level = new_dv_vlc_level[code];
} }
dv_rl_vlc[i].len = len; dv_rl_vlc[i].len = len;
dv_rl_vlc[i].level = level; dv_rl_vlc[i].level = level;
dv_rl_vlc[i].run = run; dv_rl_vlc[i].run = run;
} }
free_vlc(&dv_vlc); free_vlc(&dv_vlc);
...@@ -196,10 +196,10 @@ static av_cold int dvvideo_init(AVCodecContext *avctx) ...@@ -196,10 +196,10 @@ static av_cold int dvvideo_init(AVCodecContext *avctx)
if (dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].size != 0) if (dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].size != 0)
continue; continue;
dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].vlc = dv_vlc_bits[i] << dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].vlc =
(!!dv_vlc_level[i]); dv_vlc_bits[i] << (!!dv_vlc_level[i]);
dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].size = dv_vlc_len[i] + dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].size =
(!!dv_vlc_level[i]); dv_vlc_len[i] + (!!dv_vlc_level[i]);
} }
for (i = 0; i < DV_VLC_MAP_RUN_SIZE; i++) { for (i = 0; i < DV_VLC_MAP_RUN_SIZE; i++) {
#ifdef DV_CODEC_TINY_TARGET #ifdef DV_CODEC_TINY_TARGET
...@@ -233,18 +233,18 @@ static av_cold int dvvideo_init(AVCodecContext *avctx) ...@@ -233,18 +233,18 @@ static av_cold int dvvideo_init(AVCodecContext *avctx)
s->get_pixels = dsp.get_pixels; s->get_pixels = dsp.get_pixels;
/* 88DCT setup */ /* 88DCT setup */
s->fdct[0] = dsp.fdct; s->fdct[0] = dsp.fdct;
s->idct_put[0] = dsp.idct_put; s->idct_put[0] = dsp.idct_put;
for (i=0; i<64; i++) for (i = 0; i < 64; i++)
s->dv_zigzag[0][i] = dsp.idct_permutation[ff_zigzag_direct[i]]; s->dv_zigzag[0][i] = dsp.idct_permutation[ff_zigzag_direct[i]];
/* 248DCT setup */ /* 248DCT setup */
s->fdct[1] = dsp.fdct248; s->fdct[1] = dsp.fdct248;
s->idct_put[1] = ff_simple_idct248_put; // FIXME: need to add it to DSP s->idct_put[1] = ff_simple_idct248_put; // FIXME: need to add it to DSP
if(avctx->lowres){ if (avctx->lowres){
for (i=0; i<64; i++){ for (i = 0; i < 64; i++){
int j= ff_zigzag248_direct[i]; int j = ff_zigzag248_direct[i];
s->dv_zigzag[1][i] = dsp.idct_permutation[(j&7) + (j&8)*4 + (j&48)/2]; s->dv_zigzag[1][i] = dsp.idct_permutation[(j & 7) + (j & 8) * 4 + (j & 48) / 2];
} }
}else }else
memcpy(s->dv_zigzag[1], ff_zigzag248_direct, 64); memcpy(s->dv_zigzag[1], ff_zigzag248_direct, 64);
...@@ -253,7 +253,7 @@ static av_cold int dvvideo_init(AVCodecContext *avctx) ...@@ -253,7 +253,7 @@ static av_cold int dvvideo_init(AVCodecContext *avctx)
dv_build_unquantize_tables(s, dsp.idct_permutation); dv_build_unquantize_tables(s, dsp.idct_permutation);
avctx->coded_frame = &s->picture; avctx->coded_frame = &s->picture;
s->avctx= avctx; s->avctx = avctx;
return 0; return 0;
} }
...@@ -290,9 +290,9 @@ static inline int put_bits_left(PutBitContext* s) ...@@ -290,9 +290,9 @@ static inline int put_bits_left(PutBitContext* s)
static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, DCTELEM *block) static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, DCTELEM *block)
{ {
int last_index = gb->size_in_bits; int last_index = gb->size_in_bits;
const uint8_t *scan_table = mb->scan_table; const uint8_t *scan_table = mb->scan_table;
const uint32_t *factor_table = mb->factor_table; const uint32_t *factor_table = mb->factor_table;
int pos = mb->pos; int pos = mb->pos;
int partial_bit_count = mb->partial_bit_count; int partial_bit_count = mb->partial_bit_count;
int level, run, vlc_len, index; int level, run, vlc_len, index;
...@@ -302,25 +302,25 @@ static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, DCTELEM *block) ...@@ -302,25 +302,25 @@ static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, DCTELEM *block)
/* if we must parse a partial vlc, we do it here */ /* if we must parse a partial vlc, we do it here */
if (partial_bit_count > 0) { if (partial_bit_count > 0) {
re_cache = ((unsigned)re_cache >> partial_bit_count) | re_cache = ((unsigned)re_cache >> partial_bit_count) |
(mb->partial_bit_buffer << (sizeof(re_cache)*8 - partial_bit_count)); (mb->partial_bit_buffer << (sizeof(re_cache) * 8 - partial_bit_count));
re_index -= partial_bit_count; re_index -= partial_bit_count;
mb->partial_bit_count = 0; mb->partial_bit_count = 0;
} }
/* get the AC coefficients until last_index is reached */ /* get the AC coefficients until last_index is reached */
for(;;) { for (;;) {
#ifdef VLC_DEBUG #ifdef VLC_DEBUG
printf("%2d: bits=%04x index=%d\n", pos, SHOW_UBITS(re, gb, 16), re_index); printf("%2d: bits=%04x index=%d\n", pos, SHOW_UBITS(re, gb, 16), re_index);
#endif #endif
/* our own optimized GET_RL_VLC */ /* our own optimized GET_RL_VLC */
index = NEG_USR32(re_cache, TEX_VLC_BITS); index = NEG_USR32(re_cache, TEX_VLC_BITS);
vlc_len = dv_rl_vlc[index].len; vlc_len = dv_rl_vlc[index].len;
if (vlc_len < 0) { if (vlc_len < 0) {
index = NEG_USR32((unsigned)re_cache << TEX_VLC_BITS, -vlc_len) + dv_rl_vlc[index].level; index = NEG_USR32((unsigned)re_cache << TEX_VLC_BITS, -vlc_len) + dv_rl_vlc[index].level;
vlc_len = TEX_VLC_BITS - vlc_len; vlc_len = TEX_VLC_BITS - vlc_len;
} }
level = dv_rl_vlc[index].level; level = dv_rl_vlc[index].level;
run = dv_rl_vlc[index].run; run = dv_rl_vlc[index].run;
/* gotta check if we're still within gb boundaries */ /* gotta check if we're still within gb boundaries */
if (re_index + vlc_len > last_index) { if (re_index + vlc_len > last_index) {
...@@ -339,7 +339,7 @@ static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, DCTELEM *block) ...@@ -339,7 +339,7 @@ static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, DCTELEM *block)
if (pos >= 64) if (pos >= 64)
break; break;
level = (level*factor_table[pos] + (1 << (dv_iweight_bits-1))) >> dv_iweight_bits; level = (level * factor_table[pos] + (1 << (dv_iweight_bits - 1))) >> dv_iweight_bits;
block[scan_table[pos]] = level; block[scan_table[pos]] = level;
UPDATE_CACHE(re, gb); UPDATE_CACHE(re, gb);
...@@ -362,7 +362,7 @@ static inline void bit_copy(PutBitContext *pb, GetBitContext *gb) ...@@ -362,7 +362,7 @@ static inline void bit_copy(PutBitContext *pb, GetBitContext *gb)
/* mb_x and mb_y are in units of 8 pixels */ /* mb_x and mb_y are in units of 8 pixels */
static inline void dv_decode_video_segment(DVVideoContext *s, static inline void dv_decode_video_segment(DVVideoContext *s,
const uint8_t *buf_ptr1, const uint8_t *buf_ptr1,
const uint16_t *mb_pos_ptr) const uint16_t *mb_pos_ptr)
{ {
int quant, dc, dct_mode, class1, j; int quant, dc, dct_mode, class1, j;
...@@ -378,43 +378,43 @@ static inline void dv_decode_video_segment(DVVideoContext *s, ...@@ -378,43 +378,43 @@ static inline void dv_decode_video_segment(DVVideoContext *s,
DECLARE_ALIGNED_16(DCTELEM, sblock[5*DV_MAX_BPM][64]); DECLARE_ALIGNED_16(DCTELEM, sblock[5*DV_MAX_BPM][64]);
DECLARE_ALIGNED_8(uint8_t, mb_bit_buffer[80 + 4]); /* allow some slack */ DECLARE_ALIGNED_8(uint8_t, mb_bit_buffer[80 + 4]); /* allow some slack */
DECLARE_ALIGNED_8(uint8_t, vs_bit_buffer[5 * 80 + 4]); /* allow some slack */ DECLARE_ALIGNED_8(uint8_t, vs_bit_buffer[5 * 80 + 4]); /* allow some slack */
const int log2_blocksize= 3-s->avctx->lowres; const int log2_blocksize = 3-s->avctx->lowres;
int is_field_mode[5]; int is_field_mode[5];
assert((((int)mb_bit_buffer)&7)==0); assert((((int)mb_bit_buffer) & 7) == 0);
assert((((int)vs_bit_buffer)&7)==0); assert((((int)vs_bit_buffer) & 7) == 0);
memset(sblock, 0, sizeof(sblock)); memset(sblock, 0, sizeof(sblock));
/* pass 1 : read DC and AC coefficients in blocks */ /* pass 1 : read DC and AC coefficients in blocks */
buf_ptr = buf_ptr1; buf_ptr = buf_ptr1;
block1 = &sblock[0][0]; block1 = &sblock[0][0];
mb1 = mb_data; mb1 = mb_data;
init_put_bits(&vs_pb, vs_bit_buffer, 5 * 80); init_put_bits(&vs_pb, vs_bit_buffer, 5 * 80);
for(mb_index = 0; mb_index < 5; mb_index++, mb1 += s->sys->bpm, block1 += s->sys->bpm * 64) { for (mb_index = 0; mb_index < 5; mb_index++, mb1 += s->sys->bpm, block1 += s->sys->bpm * 64) {
/* skip header */ /* skip header */
quant = buf_ptr[3] & 0x0f; quant = buf_ptr[3] & 0x0f;
buf_ptr += 4; buf_ptr += 4;
init_put_bits(&pb, mb_bit_buffer, 80); init_put_bits(&pb, mb_bit_buffer, 80);
mb = mb1; mb = mb1;
block = block1; block = block1;
is_field_mode[mb_index] = 0; is_field_mode[mb_index] = 0;
for(j = 0;j < s->sys->bpm; j++) { for (j = 0; j < s->sys->bpm; j++) {
last_index = s->sys->block_sizes[j]; last_index = s->sys->block_sizes[j];
init_get_bits(&gb, buf_ptr, last_index); init_get_bits(&gb, buf_ptr, last_index);
/* get the dc */ /* get the dc */
dc = get_sbits(&gb, 9); dc = get_sbits(&gb, 9);
dct_mode = get_bits1(&gb); dct_mode = get_bits1(&gb);
class1 = get_bits(&gb, 2); class1 = get_bits(&gb, 2);
if (DV_PROFILE_IS_HD(s->sys)) { if (DV_PROFILE_IS_HD(s->sys)) {
mb->idct_put = s->idct_put[0]; mb->idct_put = s->idct_put[0];
mb->scan_table = s->dv_zigzag[0]; mb->scan_table = s->dv_zigzag[0];
mb->factor_table = s->dv100_idct_factor[((s->sys->height == 720)<<1)|(j >= 4)][class1][quant]; mb->factor_table = s->dv100_idct_factor[((s->sys->height == 720) << 1) | (j >= 4)][class1][quant];
is_field_mode[mb_index] |= !j && dct_mode; is_field_mode[mb_index] |= !j && dct_mode;
} else { } else {
mb->idct_put = s->idct_put[dct_mode && log2_blocksize==3]; mb->idct_put = s->idct_put[dct_mode && log2_blocksize == 3];
mb->scan_table = s->dv_zigzag[dct_mode]; mb->scan_table = s->dv_zigzag[dct_mode];
mb->factor_table = s->dv_idct_factor[class1 == 3][dct_mode] mb->factor_table = s->dv_idct_factor[class1 == 3][dct_mode]
[quant + dv_quant_offset[class1]]; [quant + dv_quant_offset[class1]];
} }
...@@ -424,7 +424,7 @@ static inline void dv_decode_video_segment(DVVideoContext *s, ...@@ -424,7 +424,7 @@ static inline void dv_decode_video_segment(DVVideoContext *s,
dc += 1024; dc += 1024;
block[0] = dc; block[0] = dc;
buf_ptr += last_index >> 3; buf_ptr += last_index >> 3;
mb->pos = 0; mb->pos = 0;
mb->partial_bit_count = 0; mb->partial_bit_count = 0;
#ifdef VLC_DEBUG #ifdef VLC_DEBUG
...@@ -446,10 +446,10 @@ static inline void dv_decode_video_segment(DVVideoContext *s, ...@@ -446,10 +446,10 @@ static inline void dv_decode_video_segment(DVVideoContext *s,
printf("***pass 2 size=%d MB#=%d\n", put_bits_count(&pb), mb_index); printf("***pass 2 size=%d MB#=%d\n", put_bits_count(&pb), mb_index);
#endif #endif
block = block1; block = block1;
mb = mb1; mb = mb1;
init_get_bits(&gb, mb_bit_buffer, put_bits_count(&pb)); init_get_bits(&gb, mb_bit_buffer, put_bits_count(&pb));
flush_put_bits(&pb); flush_put_bits(&pb);
for(j = 0;j < s->sys->bpm; j++, block += 64, mb++) { for (j = 0; j < s->sys->bpm; j++, block += 64, mb++) {
if (mb->pos < 64 && get_bits_left(&gb) > 0) { if (mb->pos < 64 && get_bits_left(&gb) > 0) {
dv_decode_ac(&gb, mb, block); dv_decode_ac(&gb, mb, block);
/* if still not finished, no need to parse other blocks */ /* if still not finished, no need to parse other blocks */
...@@ -468,11 +468,11 @@ static inline void dv_decode_video_segment(DVVideoContext *s, ...@@ -468,11 +468,11 @@ static inline void dv_decode_video_segment(DVVideoContext *s,
printf("***pass 3 size=%d\n", put_bits_count(&vs_pb)); printf("***pass 3 size=%d\n", put_bits_count(&vs_pb));
#endif #endif
block = &sblock[0][0]; block = &sblock[0][0];
mb = mb_data; mb = mb_data;
init_get_bits(&gb, vs_bit_buffer, put_bits_count(&vs_pb)); init_get_bits(&gb, vs_bit_buffer, put_bits_count(&vs_pb));
flush_put_bits(&vs_pb); flush_put_bits(&vs_pb);
for(mb_index = 0; mb_index < 5; mb_index++) { for (mb_index = 0; mb_index < 5; mb_index++) {
for(j = 0;j < s->sys->bpm; j++) { for (j = 0; j < s->sys->bpm; j++) {
if (mb->pos < 64) { if (mb->pos < 64) {
#ifdef VLC_DEBUG #ifdef VLC_DEBUG
printf("start %d:%d\n", mb_index, j); printf("start %d:%d\n", mb_index, j);
...@@ -488,41 +488,41 @@ static inline void dv_decode_video_segment(DVVideoContext *s, ...@@ -488,41 +488,41 @@ static inline void dv_decode_video_segment(DVVideoContext *s,
/* compute idct and place blocks */ /* compute idct and place blocks */
block = &sblock[0][0]; block = &sblock[0][0];
mb = mb_data; mb = mb_data;
for(mb_index = 0; mb_index < 5; mb_index++) { for (mb_index = 0; mb_index < 5; mb_index++) {
v = *mb_pos_ptr++; v = *mb_pos_ptr++;
mb_x = v & 0xff; mb_x = v & 0xff;
mb_y = v >> 8; mb_y = v >> 8;
/* We work with 720p frames split in half. The odd half-frame (chan==2,3) is displaced :-( */ /* We work with 720p frames split in half. The odd half-frame (chan==2,3) is displaced :-( */
if (s->sys->height == 720 && !(s->buf[1]&0x0C)) { if (s->sys->height == 720 && !(s->buf[1] & 0x0C)) {
mb_y -= (mb_y>17)?18:-72; /* shifting the Y coordinate down by 72/2 macroblocks */ mb_y -= (mb_y > 17) ? 18 : -72; /* shifting the Y coordinate down by 72/2 macroblocks */
} }
/* idct_put'ting luminance */ /* idct_put'ting luminance */
if ((s->sys->pix_fmt == PIX_FMT_YUV420P) || if ((s->sys->pix_fmt == PIX_FMT_YUV420P) ||
(s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) || (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
(s->sys->height >= 720 && mb_y != 134)) { (s->sys->height >= 720 && mb_y != 134)) {
y_stride = (s->picture.linesize[0]<<((!is_field_mode[mb_index])*log2_blocksize)); y_stride = (s->picture.linesize[0] << ((!is_field_mode[mb_index]) * log2_blocksize));
} else { } else {
y_stride = (2<<log2_blocksize); y_stride = (2 << log2_blocksize);
} }
y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x)<<log2_blocksize); y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x) << log2_blocksize);
linesize = s->picture.linesize[0]<<is_field_mode[mb_index]; linesize = s->picture.linesize[0] << is_field_mode[mb_index];
mb[0] .idct_put(y_ptr , linesize, block + 0*64); mb[0] .idct_put(y_ptr , linesize, block + 0*64);
if (s->sys->video_stype == 4) { /* SD 422 */ if (s->sys->video_stype == 4) { /* SD 422 */
mb[2].idct_put(y_ptr + (1<<log2_blocksize) , linesize, block + 2*64); mb[2].idct_put(y_ptr + (1 << log2_blocksize) , linesize, block + 2*64);
} else { } else {
mb[1].idct_put(y_ptr + (1<<log2_blocksize) , linesize, block + 1*64); mb[1].idct_put(y_ptr + (1 << log2_blocksize) , linesize, block + 1*64);
mb[2].idct_put(y_ptr + y_stride, linesize, block + 2*64); mb[2].idct_put(y_ptr + y_stride, linesize, block + 2*64);
mb[3].idct_put(y_ptr + (1<<log2_blocksize) + y_stride, linesize, block + 3*64); mb[3].idct_put(y_ptr + (1 << log2_blocksize) + y_stride, linesize, block + 3*64);
} }
mb += 4; mb += 4;
block += 4*64; block += 4*64;
/* idct_put'ting chrominance */ /* idct_put'ting chrominance */
c_offset = (((mb_y>>(s->sys->pix_fmt == PIX_FMT_YUV420P)) * s->picture.linesize[1] + c_offset = (((mb_y >> (s->sys->pix_fmt == PIX_FMT_YUV420P)) * s->picture.linesize[1] +
(mb_x>>((s->sys->pix_fmt == PIX_FMT_YUV411P)?2:1)))<<log2_blocksize); (mb_x >> ((s->sys->pix_fmt == PIX_FMT_YUV411P) ? 2 : 1))) << log2_blocksize);
for(j=2; j; j--) { for (j = 2; j; j--) {
uint8_t *c_ptr = s->picture.data[j] + c_offset; uint8_t *c_ptr = s->picture.data[j] + c_offset;
if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) { if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
uint64_t aligned_pixels[64/8]; uint64_t aligned_pixels[64/8];
...@@ -530,22 +530,22 @@ static inline void dv_decode_video_segment(DVVideoContext *s, ...@@ -530,22 +530,22 @@ static inline void dv_decode_video_segment(DVVideoContext *s,
uint8_t *c_ptr1, *ptr1; uint8_t *c_ptr1, *ptr1;
int x, y; int x, y;
mb->idct_put(pixels, 8, block); mb->idct_put(pixels, 8, block);
for(y = 0; y < (1<<log2_blocksize); y++, c_ptr += s->picture.linesize[j], pixels += 8) { for (y = 0; y < (1 << log2_blocksize); y++, c_ptr += s->picture.linesize[j], pixels += 8) {
ptr1= pixels + (1<<(log2_blocksize-1)); ptr1 = pixels + (1 << (log2_blocksize - 1));
c_ptr1 = c_ptr + (s->picture.linesize[j]<<log2_blocksize); c_ptr1 = c_ptr + (s->picture.linesize[j] << log2_blocksize);
for(x=0; x < (1<<(log2_blocksize-1)); x++) { for (x = 0; x < (1 << (log2_blocksize - 1)); x++) {
c_ptr[x]= pixels[x]; c_ptr[x] = pixels[x];
c_ptr1[x]= ptr1[x]; c_ptr1[x] = ptr1[x];
} }
} }
block += 64; mb++; block += 64; mb++;
} else { } else {
y_stride = (mb_y == 134) ? (1<<log2_blocksize) : y_stride = (mb_y == 134) ? (1 << log2_blocksize) :
s->picture.linesize[j]<<((!is_field_mode[mb_index])*log2_blocksize); s->picture.linesize[j] << ((!is_field_mode[mb_index]) * log2_blocksize);
linesize = s->picture.linesize[j]<<is_field_mode[mb_index]; linesize = s->picture.linesize[j] << is_field_mode[mb_index];
(mb++)-> idct_put(c_ptr , linesize, block); block+=64; (mb++)-> idct_put(c_ptr , linesize, block); block += 64;
if (s->sys->bpm == 8) { if (s->sys->bpm == 8) {
(mb++)->idct_put(c_ptr + y_stride, linesize, block); block+=64; (mb++)->idct_put(c_ptr + y_stride, linesize, block); block += 64;
} }
} }
} }
...@@ -572,7 +572,7 @@ static av_always_inline int dv_rl2vlc(int run, int level, int sign, uint32_t* vl ...@@ -572,7 +572,7 @@ static av_always_inline int dv_rl2vlc(int run, int level, int sign, uint32_t* vl
if (run) { if (run) {
*vlc |= ((run < 16) ? dv_vlc_map[run-1][0].vlc : *vlc |= ((run < 16) ? dv_vlc_map[run-1][0].vlc :
(0x1f80 | (run - 1))) << size; (0x1f80 | (run - 1))) << size;
size += (run < 16) ? dv_vlc_map[run-1][0].size : 13; size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
} }
} }
...@@ -608,39 +608,39 @@ static av_always_inline int dv_rl2vlc_size(int run, int l) ...@@ -608,39 +608,39 @@ static av_always_inline int dv_rl2vlc_size(int run, int l)
#endif #endif
typedef struct EncBlockInfo { typedef struct EncBlockInfo {
int area_q[4]; int area_q[4];
int bit_size[4]; int bit_size[4];
int prev[5]; int prev[5];
int cur_ac; int cur_ac;
int cno; int cno;
int dct_mode; int dct_mode;
DCTELEM mb[64]; DCTELEM mb[64];
uint8_t next[64]; uint8_t next[64];
uint8_t sign[64]; uint8_t sign[64];
uint8_t partial_bit_count; uint8_t partial_bit_count;
uint32_t partial_bit_buffer; /* we can't use uint16_t here */ uint32_t partial_bit_buffer; /* we can't use uint16_t here */
} EncBlockInfo; } EncBlockInfo;
static av_always_inline PutBitContext* dv_encode_ac(EncBlockInfo* bi, PutBitContext* pb_pool, static av_always_inline PutBitContext* dv_encode_ac(EncBlockInfo* bi,
PutBitContext* pb_end) PutBitContext* pb_pool,
PutBitContext* pb_end)
{ {
int prev; int prev, bits_left;
int bits_left;
PutBitContext* pb = pb_pool; PutBitContext* pb = pb_pool;
int size = bi->partial_bit_count; int size = bi->partial_bit_count;
uint32_t vlc = bi->partial_bit_buffer; uint32_t vlc = bi->partial_bit_buffer;
bi->partial_bit_count = bi->partial_bit_buffer = 0; bi->partial_bit_count = bi->partial_bit_buffer = 0;
for(;;){ for (;;){
/* Find suitable storage space */ /* Find suitable storage space */
for (; size > (bits_left = put_bits_left(pb)); pb++) { for (; size > (bits_left = put_bits_left(pb)); pb++) {
if (bits_left) { if (bits_left) {
size -= bits_left; size -= bits_left;
put_bits(pb, bits_left, vlc >> size); put_bits(pb, bits_left, vlc >> size);
vlc = vlc & ((1<<size)-1); vlc = vlc & ((1 << size) - 1);
} }
if (pb + 1 >= pb_end) { if (pb + 1 >= pb_end) {
bi->partial_bit_count = size; bi->partial_bit_count = size;
bi->partial_bit_buffer = vlc; bi->partial_bit_buffer = vlc;
return pb; return pb;
} }
...@@ -649,13 +649,13 @@ static av_always_inline PutBitContext* dv_encode_ac(EncBlockInfo* bi, PutBitCont ...@@ -649,13 +649,13 @@ static av_always_inline PutBitContext* dv_encode_ac(EncBlockInfo* bi, PutBitCont
/* Store VLC */ /* Store VLC */
put_bits(pb, size, vlc); put_bits(pb, size, vlc);
if(bi->cur_ac>=64) if (bi->cur_ac >= 64)
break; break;
/* Construct the next VLC */ /* Construct the next VLC */
prev= bi->cur_ac; prev = bi->cur_ac;
bi->cur_ac = bi->next[prev]; bi->cur_ac = bi->next[prev];
if(bi->cur_ac < 64){ if (bi->cur_ac < 64){
size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac], bi->sign[bi->cur_ac], &vlc); size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac], bi->sign[bi->cur_ac], &vlc);
} else { } else {
size = 4; vlc = 6; /* End Of Block stamp */ size = 4; vlc = 6; /* End Of Block stamp */
...@@ -665,7 +665,8 @@ static av_always_inline PutBitContext* dv_encode_ac(EncBlockInfo* bi, PutBitCont ...@@ -665,7 +665,8 @@ static av_always_inline PutBitContext* dv_encode_ac(EncBlockInfo* bi, PutBitCont
} }
static av_always_inline void dv_set_class_number(DCTELEM* blk, EncBlockInfo* bi, static av_always_inline void dv_set_class_number(DCTELEM* blk, EncBlockInfo* bi,
const uint8_t* zigzag_scan, const int *weight, int bias) const uint8_t* zigzag_scan,
const int *weight, int bias)
{ {
int i, area; int i, area;
/* We offer two different methods for class number assignment: the /* We offer two different methods for class number assignment: the
...@@ -683,50 +684,51 @@ static av_always_inline void dv_set_class_number(DCTELEM* blk, EncBlockInfo* bi, ...@@ -683,50 +684,51 @@ static av_always_inline void dv_set_class_number(DCTELEM* blk, EncBlockInfo* bi,
#else /* improved FFmpeg method */ #else /* improved FFmpeg method */
static const int classes[] = {-1, -1, 255, 0xffff}; static const int classes[] = {-1, -1, 255, 0xffff};
#endif #endif
int max=classes[0]; int max = classes[0];
int prev=0; int prev = 0;
bi->mb[0] = blk[0]; bi->mb[0] = blk[0];
for (area = 0; area < 4; area++) { for (area = 0; area < 4; area++) {
bi->prev[area] = prev; bi->prev[area] = prev;
bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :) bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
for (i=mb_area_start[area]; i<mb_area_start[area+1]; i++) { for (i = mb_area_start[area]; i < mb_area_start[area+1]; i++) {
int level = blk[zigzag_scan[i]]; int level = blk[zigzag_scan[i]];
if (level+15 > 30U) { if (level + 15 > 30U) {
bi->sign[i] = (level>>31)&1; bi->sign[i] = (level >> 31) & 1;
/* weigh it and and shift down into range, adding for rounding */ /* weigh it and and shift down into range, adding for rounding */
/* the extra division by a factor of 2^4 reverses the 8x expansion of the DCT /* the extra division by a factor of 2^4 reverses the 8x expansion of the DCT
AND the 2x doubling of the weights */ AND the 2x doubling of the weights */
level = (FFABS(level) * weight[i] + (1<<(dv_weight_bits+3))) >> (dv_weight_bits+4); level = (FFABS(level) * weight[i] + (1 << (dv_weight_bits+3))) >> (dv_weight_bits+4);
bi->mb[i] = level; bi->mb[i] = level;
if(level>max) max= level; if (level > max)
max = level;
bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, level); bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, level);
bi->next[prev]= i; bi->next[prev]= i;
prev= i; prev = i;
} }
} }
} }
bi->next[prev]= i; bi->next[prev]= i;
for(bi->cno = 0; max > classes[bi->cno]; bi->cno++); for (bi->cno = 0; max > classes[bi->cno]; bi->cno++);
bi->cno += bias; bi->cno += bias;
if (bi->cno >= 3) { if (bi->cno >= 3) {
bi->cno = 3; bi->cno = 3;
prev=0; prev = 0;
i= bi->next[prev]; i = bi->next[prev];
for (area = 0; area < 4; area++) { for (area = 0; area < 4; area++) {
bi->prev[area] = prev; bi->prev[area] = prev;
bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :) bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
for (; i<mb_area_start[area+1]; i= bi->next[i]) { for (; i < mb_area_start[area+1]; i = bi->next[i]) {
bi->mb[i] >>=1; bi->mb[i] >>= 1;
if (bi->mb[i]) { if (bi->mb[i]) {
bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]); bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]);
bi->next[prev]= i; bi->next[prev]= i;
prev= i; prev = i;
} }
} }
} }
...@@ -738,20 +740,20 @@ static av_always_inline void dv_set_class_number(DCTELEM* blk, EncBlockInfo* bi, ...@@ -738,20 +740,20 @@ static av_always_inline void dv_set_class_number(DCTELEM* blk, EncBlockInfo* bi,
#define SC(x, y) ((s[x] - s[y]) ^ ((s[x] - s[y]) >> 7)) #define SC(x, y) ((s[x] - s[y]) ^ ((s[x] - s[y]) >> 7))
static av_always_inline int dv_guess_dct_mode(DCTELEM *blk) { static av_always_inline int dv_guess_dct_mode(DCTELEM *blk) {
DCTELEM *s; DCTELEM *s;
int score88 = 0; int score88 = 0;
int score248 = 0; int score248 = 0;
int i; int i;
/* Compute 8-8 score (small values give a better chance for 8-8 DCT) */ /* Compute 8-8 score (small values give a better chance for 8-8 DCT) */
s = blk; s = blk;
for(i=0; i<7; i++) { for (i = 0; i < 7; i++) {
score88 += SC(0, 8) + SC(1, 9) + SC(2, 10) + SC(3, 11) + score88 += SC(0, 8) + SC(1, 9) + SC(2, 10) + SC(3, 11) +
SC(4, 12) + SC(5,13) + SC(6, 14) + SC(7, 15); SC(4, 12) + SC(5,13) + SC(6, 14) + SC(7, 15);
s += 8; s += 8;
} }
/* Compute 2-4-8 score (small values give a better chance for 2-4-8 DCT) */ /* Compute 2-4-8 score (small values give a better chance for 2-4-8 DCT) */
s = blk; s = blk;
for(i=0; i<6; i++) { for (i = 0; i < 6; i++) {
score248 += SC(0, 16) + SC(1,17) + SC(2, 18) + SC(3, 19) + score248 += SC(0, 16) + SC(1,17) + SC(2, 18) + SC(3, 19) +
SC(4, 20) + SC(5,21) + SC(6, 22) + SC(7, 23); SC(4, 20) + SC(5,21) + SC(6, 22) + SC(7, 23);
s += 8; s += 8;
...@@ -766,36 +768,36 @@ static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos) ...@@ -766,36 +768,36 @@ static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos)
int i, j, k, a, prev, a2; int i, j, k, a, prev, a2;
EncBlockInfo* b; EncBlockInfo* b;
size[0] = size[1] = size[2] = size[3] = size[4] = 1<<24; size[0] = size[1] = size[2] = size[3] = size[4] = 1 << 24;
do { do {
b = blks; b = blks;
for (i=0; i<5; i++) { for (i = 0; i < 5; i++) {
if (!qnos[i]) if (!qnos[i])
continue; continue;
qnos[i]--; qnos[i]--;
size[i] = 0; size[i] = 0;
for (j=0; j<6; j++, b++) { for (j = 0; j < 6; j++, b++) {
for (a=0; a<4; a++) { for (a = 0; a < 4; a++) {
if (b->area_q[a] != dv_quant_shifts[qnos[i] + dv_quant_offset[b->cno]][a]) { if (b->area_q[a] != dv_quant_shifts[qnos[i] + dv_quant_offset[b->cno]][a]) {
b->bit_size[a] = 1; // 4 areas 4 bits for EOB :) b->bit_size[a] = 1; // 4 areas 4 bits for EOB :)
b->area_q[a]++; b->area_q[a]++;
prev= b->prev[a]; prev = b->prev[a];
assert(b->next[prev] >= mb_area_start[a+1] || b->mb[prev]); assert(b->next[prev] >= mb_area_start[a+1] || b->mb[prev]);
for (k= b->next[prev] ; k<mb_area_start[a+1]; k= b->next[k]) { for (k = b->next[prev] ; k < mb_area_start[a+1]; k = b->next[k]) {
b->mb[k] >>= 1; b->mb[k] >>= 1;
if (b->mb[k]) { if (b->mb[k]) {
b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]); b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
prev= k; prev = k;
} else { } else {
if(b->next[k] >= mb_area_start[a+1] && b->next[k]<64){ if (b->next[k] >= mb_area_start[a+1] && b->next[k]<64){
for(a2=a+1; b->next[k] >= mb_area_start[a2+1]; a2++) for (a2 = a + 1; b->next[k] >= mb_area_start[a2+1]; a2++)
b->prev[a2] = prev; b->prev[a2] = prev;
assert(a2<4); assert(a2 < 4);
assert(b->mb[b->next[k]]); assert(b->mb[b->next[k]]);
b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]]) b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]])
-dv_rl2vlc_size(b->next[k] - k - 1, b->mb[b->next[k]]); -dv_rl2vlc_size(b->next[k] - k - 1, b->mb[b->next[k]]);
assert(b->prev[a2]==k && (a2+1 >= 4 || b->prev[a2+1]!=k)); assert(b->prev[a2] == k && (a2 + 1 >= 4 || b->prev[a2+1] != k));
b->prev[a2] = prev; b->prev[a2] = prev;
} }
b->next[prev] = b->next[k]; b->next[prev] = b->next[k];
...@@ -806,23 +808,23 @@ static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos) ...@@ -806,23 +808,23 @@ static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos)
size[i] += b->bit_size[a]; size[i] += b->bit_size[a];
} }
} }
if(vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4]) if (vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4])
return; return;
} }
} while (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4]); } while (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4]);
for(a=2; a==2 || vs_total_ac_bits < size[0]; a+=a){ for (a = 2; a == 2 || vs_total_ac_bits < size[0]; a += a){
b = blks; b = blks;
size[0] = 5*6*4; //EOB size[0] = 5 * 6 * 4; //EOB
for (j=0; j<6*5; j++, b++) { for (j = 0; j < 6 *5; j++, b++) {
prev= b->prev[0]; prev = b->prev[0];
for (k= b->next[prev]; k<64; k= b->next[k]) { for (k = b->next[prev]; k < 64; k = b->next[k]) {
if(b->mb[k] < a && b->mb[k] > -a){ if (b->mb[k] < a && b->mb[k] > -a){
b->next[prev] = b->next[k]; b->next[prev] = b->next[k];
}else{ }else{
size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]); size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
prev= k; prev = k;
} }
} }
} }
...@@ -851,32 +853,32 @@ static inline void dv_encode_video_segment(DVVideoContext *s, ...@@ -851,32 +853,32 @@ static inline void dv_encode_video_segment(DVVideoContext *s,
enc_blk = &enc_blks[0]; enc_blk = &enc_blks[0];
pb = &pbs[0]; pb = &pbs[0];
for(mb_index = 0; mb_index < 5; mb_index++) { for (mb_index = 0; mb_index < 5; mb_index++) {
v = *mb_pos_ptr++; v = *mb_pos_ptr++;
mb_x = v & 0xff; mb_x = v & 0xff;
mb_y = v >> 8; mb_y = v >> 8;
y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x)<<3); y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x) << 3);
c_offset = (((mb_y>>(s->sys->pix_fmt == PIX_FMT_YUV420P)) * s->picture.linesize[1] + c_offset = (((mb_y >> (s->sys->pix_fmt == PIX_FMT_YUV420P)) * s->picture.linesize[1] +
(mb_x>>((s->sys->pix_fmt == PIX_FMT_YUV411P)?2:1)))<<3); (mb_x >> ((s->sys->pix_fmt == PIX_FMT_YUV411P) ? 2 : 1))) << 3);
do_edge_wrap = 0; do_edge_wrap = 0;
qnos[mb_index] = 15; /* No quantization */ qnos[mb_index] = 15; /* No quantization */
ptr = dif + mb_index*80 + 4; ptr = dif + mb_index*80 + 4;
for(j = 0;j < 6; j++) { for (j = 0; j < 6; j++) {
int dummy = 0; int dummy = 0;
if (s->sys->pix_fmt == PIX_FMT_YUV422P) { /* 4:2:2 */ if (s->sys->pix_fmt == PIX_FMT_YUV422P) { /* 4:2:2 */
if (j == 0 || j == 2) { if (j == 0 || j == 2) {
/* Y0 Y1 */ /* Y0 Y1 */
data = y_ptr + ((j>>1) * 8); data = y_ptr + ((j >> 1) * 8);
linesize = s->picture.linesize[0]; linesize = s->picture.linesize[0];
} else if (j > 3) { } else if (j > 3) {
/* Cr Cb */ /* Cr Cb */
data = s->picture.data[6 - j] + c_offset; data = s->picture.data[6 - j] + c_offset;
linesize = s->picture.linesize[6 - j]; linesize = s->picture.linesize[6 - j];
} else { } else {
/* j=1 and j=3 are "dummy" blocks, used for AC data only */ /* j=1 and j=3 are "dummy" blocks, used for AC data only */
data = 0; data = 0;
linesize = 0; linesize = 0;
dummy = 1; dummy = 1;
} }
} else { /* 4:1:1 or 4:2:0 */ } else { /* 4:1:1 or 4:2:0 */
if (j < 4) { /* Four Y blocks */ if (j < 4) { /* Four Y blocks */
...@@ -889,7 +891,7 @@ static inline void dv_encode_video_segment(DVVideoContext *s, ...@@ -889,7 +891,7 @@ static inline void dv_encode_video_segment(DVVideoContext *s,
linesize = s->picture.linesize[0]; linesize = s->picture.linesize[0];
} else { /* Cr and Cb blocks */ } else { /* Cr and Cb blocks */
/* don't ask Fabrice why they inverted Cb and Cr ! */ /* don't ask Fabrice why they inverted Cb and Cr ! */
data = s->picture.data[6 - j] + c_offset; data = s->picture.data [6 - j] + c_offset;
linesize = s->picture.linesize[6 - j]; linesize = s->picture.linesize[6 - j];
if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8))
do_edge_wrap = 1; do_edge_wrap = 1;
...@@ -900,7 +902,7 @@ static inline void dv_encode_video_segment(DVVideoContext *s, ...@@ -900,7 +902,7 @@ static inline void dv_encode_video_segment(DVVideoContext *s,
if (do_edge_wrap) { /* Edge wrap copy: 4x16 -> 8x8 */ if (do_edge_wrap) { /* Edge wrap copy: 4x16 -> 8x8 */
uint8_t* d; uint8_t* d;
DCTELEM *b = block; DCTELEM *b = block;
for (i=0;i<8;i++) { for (i = 0; i < 8; i++) {
d = data + 8 * linesize; d = data + 8 * linesize;
b[0] = data[0]; b[1] = data[1]; b[2] = data[2]; b[3] = data[3]; b[0] = data[0]; b[1] = data[1]; b[2] = data[2]; b[3] = data[3];
b[4] = d[0]; b[5] = d[1]; b[6] = d[2]; b[7] = d[3]; b[4] = d[0]; b[5] = d[1]; b[6] = d[2]; b[7] = d[3];
...@@ -912,7 +914,7 @@ static inline void dv_encode_video_segment(DVVideoContext *s, ...@@ -912,7 +914,7 @@ static inline void dv_encode_video_segment(DVVideoContext *s,
s->get_pixels(block, data, linesize); s->get_pixels(block, data, linesize);
} }
if(s->avctx->flags & CODEC_FLAG_INTERLACED_DCT) if (s->avctx->flags & CODEC_FLAG_INTERLACED_DCT)
enc_blk->dct_mode = dv_guess_dct_mode(block); enc_blk->dct_mode = dv_guess_dct_mode(block);
else else
enc_blk->dct_mode = 0; enc_blk->dct_mode = 0;
...@@ -950,33 +952,33 @@ static inline void dv_encode_video_segment(DVVideoContext *s, ...@@ -950,33 +952,33 @@ static inline void dv_encode_video_segment(DVVideoContext *s,
if (vs_total_ac_bits < vs_bit_size) if (vs_total_ac_bits < vs_bit_size)
dv_guess_qnos(&enc_blks[0], &qnos[0]); dv_guess_qnos(&enc_blks[0], &qnos[0]);
for (i=0; i<5; i++) { for (i = 0; i < 5; i++) {
dif[i*80 + 3] = qnos[i]; dif[i*80 + 3] = qnos[i];
} }
/* First pass over individual cells only */ /* First pass over individual cells only */
for (j=0; j<5*6; j++) for (j = 0; j < 5 * 6; j++)
dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j+1]); dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j+1]);
/* Second pass over each MB space */ /* Second pass over each MB space */
for (j=0; j<5*6; j+=6) { for (j = 0; j < 5 * 6; j += 6) {
pb= &pbs[j]; pb = &pbs[j];
for (i=0; i<6; i++) { for (i = 0; i < 6; i++) {
if (enc_blks[i+j].partial_bit_count) if (enc_blks[i+j].partial_bit_count)
pb=dv_encode_ac(&enc_blks[i+j], pb, &pbs[j+6]); pb = dv_encode_ac(&enc_blks[i+j], pb, &pbs[j+6]);
} }
} }
/* Third and final pass over the whole video segment space */ /* Third and final pass over the whole video segment space */
pb= &pbs[0]; pb = &pbs[0];
for (j=0; j<5*6; j++) { for (j = 0; j < 5 * 6; j++) {
if (enc_blks[j].partial_bit_count) if (enc_blks[j].partial_bit_count)
pb=dv_encode_ac(&enc_blks[j], pb, &pbs[6*5]); pb = dv_encode_ac(&enc_blks[j], pb, &pbs[6*5]);
if (enc_blks[j].partial_bit_count) if (enc_blks[j].partial_bit_count)
av_log(NULL, AV_LOG_ERROR, "ac bitstream overflow\n"); av_log(NULL, AV_LOG_ERROR, "ac bitstream overflow\n");
} }
for (j=0; j<5*6; j++) for (j = 0; j < 5 * 6; j++)
flush_put_bits(&pbs[j]); flush_put_bits(&pbs[j]);
} }
...@@ -1002,8 +1004,10 @@ static int dv_decode_mt(AVCodecContext *avctx, void* sl) ...@@ -1002,8 +1004,10 @@ static int dv_decode_mt(AVCodecContext *avctx, void* sl)
(DV_PROFILE_IS_720p50(s->sys) && seq > 9)) (DV_PROFILE_IS_720p50(s->sys) && seq > 9))
return 0; return 0;
dv_decode_video_segment(s, &s->buf[(seq*6+(chan_slice/3)+chan_slice*5+7)*80 + chan_offset], dv_decode_video_segment(s, &s->buf[(seq * 6 + (chan_slice / 3)
&s->sys->video_place[slice*5]); + chan_slice * 5 + 7)
* 80 + chan_offset],
&s->sys->video_place[slice * 5]);
return 0; return 0;
} }
...@@ -1022,8 +1026,10 @@ static int dv_encode_mt(AVCodecContext *avctx, void* sl) ...@@ -1022,8 +1026,10 @@ static int dv_encode_mt(AVCodecContext *avctx, void* sl)
/* byte offset of this channel's data */ /* byte offset of this channel's data */
int chan_offset = chan * s->sys->difseg_size * 150 * 80; int chan_offset = chan * s->sys->difseg_size * 150 * 80;
dv_encode_video_segment(s, &s->buf[((chan_slice/27)*6+(chan_slice/3)+chan_slice*5+7)*80 + chan_offset], dv_encode_video_segment(s, &s->buf[((chan_slice / 27) * 6 + (chan_slice / 3)
&s->sys->video_place[slice*5]); + chan_slice * 5 + 7)
* 80 + chan_offset],
&s->sys->video_place[slice * 5]);
return 0; return 0;
} }
#endif #endif
...@@ -1041,21 +1047,21 @@ static int dvvideo_decode_frame(AVCodecContext *avctx, ...@@ -1041,21 +1047,21 @@ static int dvvideo_decode_frame(AVCodecContext *avctx,
if (!s->sys || buf_size < s->sys->frame_size) if (!s->sys || buf_size < s->sys->frame_size)
return -1; /* NOTE: we only accept several full frames */ return -1; /* NOTE: we only accept several full frames */
if(s->picture.data[0]) if (s->picture.data[0])
avctx->release_buffer(avctx, &s->picture); avctx->release_buffer(avctx, &s->picture);
s->picture.reference = 0; s->picture.reference = 0;
s->picture.key_frame = 1; s->picture.key_frame = 1;
s->picture.pict_type = FF_I_TYPE; s->picture.pict_type = FF_I_TYPE;
avctx->pix_fmt = s->sys->pix_fmt; avctx->pix_fmt = s->sys->pix_fmt;
avctx->time_base = s->sys->time_base; avctx->time_base = s->sys->time_base;
avcodec_set_dimensions(avctx, s->sys->width, s->sys->height); avcodec_set_dimensions(avctx, s->sys->width, s->sys->height);
if(avctx->get_buffer(avctx, &s->picture) < 0) { if (avctx->get_buffer(avctx, &s->picture) < 0) {
av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n"); av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
return -1; return -1;
} }
s->picture.interlaced_frame = 1; s->picture.interlaced_frame = 1;
s->picture.top_field_first = 0; s->picture.top_field_first = 0;
s->buf = buf; s->buf = buf;
avctx->execute(avctx, dv_decode_mt, (void**)&dv_anchor[0], NULL, avctx->execute(avctx, dv_decode_mt, (void**)&dv_anchor[0], NULL,
...@@ -1065,14 +1071,15 @@ static int dvvideo_decode_frame(AVCodecContext *avctx, ...@@ -1065,14 +1071,15 @@ static int dvvideo_decode_frame(AVCodecContext *avctx,
/* return image */ /* return image */
*data_size = sizeof(AVFrame); *data_size = sizeof(AVFrame);
*(AVFrame*)data= s->picture; *(AVFrame*)data = s->picture;
return s->sys->frame_size; return s->sys->frame_size;
} }
#endif /* CONFIG_DVVIDEO_DECODER */ #endif /* CONFIG_DVVIDEO_DECODER */
static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c, uint8_t* buf) static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c,
uint8_t* buf)
{ {
/* /*
* Here's what SMPTE314M says about these two: * Here's what SMPTE314M says about these two:
...@@ -1092,51 +1099,51 @@ static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c, ui ...@@ -1092,51 +1099,51 @@ static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c, ui
* 2. It is not at all clear what STYPE is used for 4:2:0 PAL * 2. It is not at all clear what STYPE is used for 4:2:0 PAL
* compression scheme (if any). * compression scheme (if any).
*/ */
int apt = (c->sys->pix_fmt == PIX_FMT_YUV420P ? 0 : 1); int apt = (c->sys->pix_fmt == PIX_FMT_YUV420P ? 0 : 1);
int stype = (c->sys->pix_fmt == PIX_FMT_YUV422P ? 4 : 0); int stype = (c->sys->pix_fmt == PIX_FMT_YUV422P ? 4 : 0);
uint8_t aspect = 0; uint8_t aspect = 0;
if((int)(av_q2d(c->avctx->sample_aspect_ratio) * c->avctx->width / c->avctx->height * 10) == 17) /* 16:9 */ if ((int)(av_q2d(c->avctx->sample_aspect_ratio) * c->avctx->width / c->avctx->height * 10) == 17) /* 16:9 */
aspect = 0x02; aspect = 0x02;
buf[0] = (uint8_t)pack_id; buf[0] = (uint8_t)pack_id;
switch (pack_id) { switch (pack_id) {
case dv_header525: /* I can't imagine why these two weren't defined as real */ case dv_header525: /* I can't imagine why these two weren't defined as real */
case dv_header625: /* packs in SMPTE314M -- they definitely look like ones */ case dv_header625: /* packs in SMPTE314M -- they definitely look like ones */
buf[1] = 0xf8 | /* reserved -- always 1 */ buf[1] = 0xf8 | /* reserved -- always 1 */
(apt & 0x07); /* APT: Track application ID */ (apt & 0x07); /* APT: Track application ID */
buf[2] = (0 << 7) | /* TF1: audio data is 0 - valid; 1 - invalid */ buf[2] = (0 << 7) | /* TF1: audio data is 0 - valid; 1 - invalid */
(0x0f << 3) | /* reserved -- always 1 */ (0x0f << 3) | /* reserved -- always 1 */
(apt & 0x07); /* AP1: Audio application ID */ (apt & 0x07); /* AP1: Audio application ID */
buf[3] = (0 << 7) | /* TF2: video data is 0 - valid; 1 - invalid */ buf[3] = (0 << 7) | /* TF2: video data is 0 - valid; 1 - invalid */
(0x0f << 3) | /* reserved -- always 1 */ (0x0f << 3) | /* reserved -- always 1 */
(apt & 0x07); /* AP2: Video application ID */ (apt & 0x07); /* AP2: Video application ID */
buf[4] = (0 << 7) | /* TF3: subcode(SSYB) is 0 - valid; 1 - invalid */ buf[4] = (0 << 7) | /* TF3: subcode(SSYB) is 0 - valid; 1 - invalid */
(0x0f << 3) | /* reserved -- always 1 */ (0x0f << 3) | /* reserved -- always 1 */
(apt & 0x07); /* AP3: Subcode application ID */ (apt & 0x07); /* AP3: Subcode application ID */
break; break;
case dv_video_source: case dv_video_source:
buf[1] = 0xff; /* reserved -- always 1 */ buf[1] = 0xff; /* reserved -- always 1 */
buf[2] = (1 << 7) | /* B/W: 0 - b/w, 1 - color */ buf[2] = (1 << 7) | /* B/W: 0 - b/w, 1 - color */
(1 << 6) | /* following CLF is valid - 0, invalid - 1 */ (1 << 6) | /* following CLF is valid - 0, invalid - 1 */
(3 << 4) | /* CLF: color frames ID (see ITU-R BT.470-4) */ (3 << 4) | /* CLF: color frames ID (see ITU-R BT.470-4) */
0xf; /* reserved -- always 1 */ 0xf; /* reserved -- always 1 */
buf[3] = (3 << 6) | /* reserved -- always 1 */ buf[3] = (3 << 6) | /* reserved -- always 1 */
(c->sys->dsf << 5) | /* system: 60fields/50fields */ (c->sys->dsf << 5) | /* system: 60fields/50fields */
stype; /* signal type video compression */ stype; /* signal type video compression */
buf[4] = 0xff; /* VISC: 0xff -- no information */ buf[4] = 0xff; /* VISC: 0xff -- no information */
break; break;
case dv_video_control: case dv_video_control:
buf[1] = (0 << 6) | /* Copy generation management (CGMS) 0 -- free */ buf[1] = (0 << 6) | /* Copy generation management (CGMS) 0 -- free */
0x3f; /* reserved -- always 1 */ 0x3f; /* reserved -- always 1 */
buf[2] = 0xc8 | /* reserved -- always b11001xxx */ buf[2] = 0xc8 | /* reserved -- always b11001xxx */
aspect; aspect;
buf[3] = (1 << 7) | /* frame/field flag 1 -- frame, 0 -- field */ buf[3] = (1 << 7) | /* frame/field flag 1 -- frame, 0 -- field */
(1 << 6) | /* first/second field flag 0 -- field 2, 1 -- field 1 */ (1 << 6) | /* first/second field flag 0 -- field 2, 1 -- field 1 */
(1 << 5) | /* frame change flag 0 -- same picture as before, 1 -- different */ (1 << 5) | /* frame change flag 0 -- same picture as before, 1 -- different */
(1 << 4) | /* 1 - interlaced, 0 - noninterlaced */ (1 << 4) | /* 1 - interlaced, 0 - noninterlaced */
0xc; /* reserved -- always b1100 */ 0xc; /* reserved -- always b1100 */
buf[4] = 0xff; /* reserved -- always 1 */ buf[4] = 0xff; /* reserved -- always 1 */
break; break;
default: default:
buf[1] = buf[2] = buf[3] = buf[4] = 0xff; buf[1] = buf[2] = buf[3] = buf[4] = 0xff;
...@@ -1203,11 +1210,11 @@ static int dvvideo_encode_frame(AVCodecContext *c, uint8_t *buf, int buf_size, ...@@ -1203,11 +1210,11 @@ static int dvvideo_encode_frame(AVCodecContext *c, uint8_t *buf, int buf_size,
s->sys = dv_codec_profile(c); s->sys = dv_codec_profile(c);
if (!s->sys) if (!s->sys)
return -1; return -1;
if(buf_size < s->sys->frame_size) if (buf_size < s->sys->frame_size)
return -1; return -1;
c->pix_fmt = s->sys->pix_fmt; c->pix_fmt = s->sys->pix_fmt;
s->picture = *((AVFrame *)data); s->picture = *((AVFrame *)data);
s->picture.key_frame = 1; s->picture.key_frame = 1;
s->picture.pict_type = FF_I_TYPE; s->picture.pict_type = FF_I_TYPE;
...@@ -1227,7 +1234,7 @@ static int dvvideo_close(AVCodecContext *c) ...@@ -1227,7 +1234,7 @@ static int dvvideo_close(AVCodecContext *c)
{ {
DVVideoContext *s = c->priv_data; DVVideoContext *s = c->priv_data;
if(s->picture.data[0]) if (s->picture.data[0])
c->release_buffer(c, &s->picture); c->release_buffer(c, &s->picture);
return 0; return 0;
...@@ -1242,7 +1249,7 @@ AVCodec dvvideo_encoder = { ...@@ -1242,7 +1249,7 @@ AVCodec dvvideo_encoder = {
sizeof(DVVideoContext), sizeof(DVVideoContext),
dvvideo_init, dvvideo_init,
dvvideo_encode_frame, dvvideo_encode_frame,
.pix_fmts = (enum PixelFormat[]) {PIX_FMT_YUV411P, PIX_FMT_YUV422P, PIX_FMT_YUV420P, PIX_FMT_NONE}, .pix_fmts = (enum PixelFormat[]) {PIX_FMT_YUV411P, PIX_FMT_YUV422P, PIX_FMT_YUV420P, PIX_FMT_NONE},
.long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"), .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
}; };
#endif // CONFIG_DVVIDEO_ENCODER #endif // CONFIG_DVVIDEO_ENCODER
......
libavcodec/dvdata.h
View file @ f94036f1
...@@ -37,26 +37,26 @@ ...@@ -37,26 +37,26 @@
* DV specs as well (e.g. SMPTE314M vs. IEC 61834). * DV specs as well (e.g. SMPTE314M vs. IEC 61834).
*/ */
typedef struct DVprofile { typedef struct DVprofile {
int dsf; /* value of the dsf in the DV header */ int dsf; /* value of the dsf in the DV header */
int video_stype; /* stype for VAUX source pack */ int video_stype; /* stype for VAUX source pack */
int frame_size; /* total size of one frame in bytes */ int frame_size; /* total size of one frame in bytes */
int difseg_size; /* number of DIF segments per DIF channel */ int difseg_size; /* number of DIF segments per DIF channel */
int n_difchan; /* number of DIF channels per frame */ int n_difchan; /* number of DIF channels per frame */
AVRational time_base; /* 1/framerate */ AVRational time_base; /* 1/framerate */
int ltc_divisor; /* FPS from the LTS standpoint */ int ltc_divisor; /* FPS from the LTS standpoint */
int height; /* picture height in pixels */ int height; /* picture height in pixels */
int width; /* picture width in pixels */ int width; /* picture width in pixels */
AVRational sar[2]; /* sample aspect ratios for 4:3 and 16:9 */ AVRational sar[2]; /* sample aspect ratios for 4:3 and 16:9 */
const uint16_t *video_place; /* positions of all DV macroblocks */ const uint16_t *video_place; /* positions of all DV macroblocks */
enum PixelFormat pix_fmt; /* picture pixel format */ enum PixelFormat pix_fmt; /* picture pixel format */
int bpm; /* blocks per macroblock */ int bpm; /* blocks per macroblock */
const uint8_t *block_sizes; /* AC block sizes, in bits */ const uint8_t *block_sizes; /* AC block sizes, in bits */
int audio_stride; /* size of audio_shuffle table */ int audio_stride; /* size of audio_shuffle table */
int audio_min_samples[3];/* min amount of audio samples */ int audio_min_samples[3]; /* min amount of audio samples */
/* for 48kHz, 44.1kHz and 32kHz */ /* for 48kHz, 44.1kHz and 32kHz */
int audio_samples_dist[5];/* how many samples are supposed to be */ int audio_samples_dist[5]; /* how many samples are supposed to be */
/* in each frame in a 5 frames window */ /* in each frame in a 5 frames window */
const uint8_t (*audio_shuffle)[9]; /* PCM shuffling table */ const uint8_t (*audio_shuffle)[9]; /* PCM shuffling table */
} DVprofile; } DVprofile;
#define NB_DV_VLC 409 #define NB_DV_VLC 409
...@@ -232,38 +232,38 @@ static const uint8_t dv_vlc_run[409] = { ...@@ -232,38 +232,38 @@ static const uint8_t dv_vlc_run[409] = {
}; };
static const uint8_t dv_vlc_level[409] = { static const uint8_t dv_vlc_level[409] = {
1, 2, 1, 3, 4, 1, 2, 5, 1, 2, 1, 3, 4, 1, 2, 5,
6, 1, 1, 7, 8, 1, 1, 2, 6, 1, 1, 7, 8, 1, 1, 2,
3, 4, 9, 10, 11, 1, 1, 1, 3, 4, 9, 10, 11, 1, 1, 1,
1, 2, 2, 3, 5, 6, 7, 12, 1, 2, 2, 3, 5, 6, 7, 12,
13, 14, 15, 16, 17, 1, 1, 1, 13, 14, 15, 16, 17, 1, 1, 1,
1, 2, 2, 3, 3, 4, 5, 8, 1, 2, 2, 3, 3, 4, 5, 8,
18, 19, 20, 21, 22, 3, 4, 5, 18, 19, 20, 21, 22, 3, 4, 5,
6, 9, 10, 11, 0, 0, 3, 4, 6, 9, 10, 11, 0, 0, 3, 4,
6, 12, 13, 14, 0, 0, 0, 0, 6, 12, 13, 14, 0, 0, 0, 0,
2, 2, 2, 2, 3, 3, 5, 7, 2, 2, 2, 2, 3, 3, 5, 7,
7, 8, 9, 10, 11, 15, 16, 17, 7, 8, 9, 10, 11, 15, 16, 17,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7,
8, 9, 10, 11, 12, 13, 14, 15, 8, 9, 10, 11, 12, 13, 14, 15,
16, 17, 18, 19, 20, 21, 22, 23, 16, 17, 18, 19, 20, 21, 22, 23,
24, 25, 26, 27, 28, 29, 30, 31, 24, 25, 26, 27, 28, 29, 30, 31,
32, 33, 34, 35, 36, 37, 38, 39, 32, 33, 34, 35, 36, 37, 38, 39,
40, 41, 42, 43, 44, 45, 46, 47, 40, 41, 42, 43, 44, 45, 46, 47,
48, 49, 50, 51, 52, 53, 54, 55, 48, 49, 50, 51, 52, 53, 54, 55,
56, 57, 58, 59, 60, 61, 62, 63, 56, 57, 58, 59, 60, 61, 62, 63,
64, 65, 66, 67, 68, 69, 70, 71, 64, 65, 66, 67, 68, 69, 70, 71,
72, 73, 74, 75, 76, 77, 78, 79, 72, 73, 74, 75, 76, 77, 78, 79,
80, 81, 82, 83, 84, 85, 86, 87, 80, 81, 82, 83, 84, 85, 86, 87,
88, 89, 90, 91, 92, 93, 94, 95, 88, 89, 90, 91, 92, 93, 94, 95,
96, 97, 98, 99, 100, 101, 102, 103, 96, 97, 98, 99, 100, 101, 102, 103,
104, 105, 106, 107, 108, 109, 110, 111, 104, 105, 106, 107, 108, 109, 110, 111,
112, 113, 114, 115, 116, 117, 118, 119, 112, 113, 114, 115, 116, 117, 118, 119,
120, 121, 122, 123, 124, 125, 126, 127, 120, 121, 122, 123, 124, 125, 126, 127,
...@@ -283,7 +283,7 @@ static const uint8_t dv_vlc_level[409] = { ...@@ -283,7 +283,7 @@ static const uint8_t dv_vlc_level[409] = {
232, 233, 234, 235, 236, 237, 238, 239, 232, 233, 234, 235, 236, 237, 238, 239,
240, 241, 242, 243, 244, 245, 246, 247, 240, 241, 242, 243, 244, 245, 246, 247,
248, 249, 250, 251, 252, 253, 254, 255, 248, 249, 250, 251, 252, 253, 254, 255,
0, 0,
}; };
/* unquant tables (not used directly) */ /* unquant tables (not used directly) */
...@@ -312,8 +312,8 @@ static const uint8_t dv_quant_shifts[22][4] = { ...@@ -312,8 +312,8 @@ static const uint8_t dv_quant_shifts[22][4] = {
{ 0,0,0,0 }, { 0,0,0,0 },
}; };
static const uint8_t dv_quant_offset[4] = { 6, 3, 0, 1 }; static const uint8_t dv_quant_offset[4] = { 6, 3, 0, 1 };
static const uint8_t dv_quant_areas[4] = { 6, 21, 43, 64 }; static const uint8_t dv_quant_areas[4] = { 6, 21, 43, 64 };
/* quantization quanta by QNO for DV100 */ /* quantization quanta by QNO for DV100 */
static const uint8_t dv100_qstep[16] = { static const uint8_t dv100_qstep[16] = {
...@@ -6360,7 +6360,8 @@ enum dv_pack_type { ...@@ -6360,7 +6360,8 @@ enum dv_pack_type {
#define DV_PROFILE_IS_1080i50(p) (((p)->video_stype == 0x14) && ((p)->dsf == 1)) #define DV_PROFILE_IS_1080i50(p) (((p)->video_stype == 0x14) && ((p)->dsf == 1))
#define DV_PROFILE_IS_720p50(p) (((p)->video_stype == 0x18) && ((p)->dsf == 1)) #define DV_PROFILE_IS_720p50(p) (((p)->video_stype == 0x18) && ((p)->dsf == 1))
/* minimum number of bytes to read from a DV stream in order to determine the profile */ /* minimum number of bytes to read from a DV stream in order to
determine the profile */
#define DV_PROFILE_BYTES (6*80) /* 6 DIF blocks */ #define DV_PROFILE_BYTES (6*80) /* 6 DIF blocks */
/** /**
...@@ -6398,21 +6399,23 @@ static const DVprofile* dv_codec_profile(AVCodecContext* codec) ...@@ -6398,21 +6399,23 @@ static const DVprofile* dv_codec_profile(AVCodecContext* codec)
int i; int i;
for (i=0; i<FF_ARRAY_ELEMS(dv_profiles); i++) for (i=0; i<FF_ARRAY_ELEMS(dv_profiles); i++)
if (codec->height == dv_profiles[i].height && codec->pix_fmt == dv_profiles[i].pix_fmt && if (codec->height == dv_profiles[i].height &&
codec->width == dv_profiles[i].width) codec->pix_fmt == dv_profiles[i].pix_fmt &&
codec->width == dv_profiles[i].width)
return &dv_profiles[i]; return &dv_profiles[i];
return NULL; return NULL;
} }
static inline int dv_write_dif_id(enum dv_section_type t, uint8_t chan_num, uint8_t seq_num, static inline int dv_write_dif_id(enum dv_section_type t, uint8_t chan_num,
uint8_t dif_num, uint8_t* buf) uint8_t seq_num, uint8_t dif_num,
uint8_t* buf)
{ {
buf[0] = (uint8_t)t; /* Section type */ buf[0] = (uint8_t)t; /* Section type */
buf[1] = (seq_num<<4) | /* DIF seq number 0-9 for 525/60; 0-11 for 625/50 */ buf[1] = (seq_num << 4) | /* DIF seq number 0-9 for 525/60; 0-11 for 625/50 */
(chan_num << 3) | /* FSC: for 50Mb/s 0 - first channel; 1 - second */ (chan_num << 3) | /* FSC: for 50Mb/s 0 - first channel; 1 - second */
7; /* reserved -- always 1 */ 7; /* reserved -- always 1 */
buf[2] = dif_num; /* DIF block number Video: 0-134, Audio: 0-8 */ buf[2] = dif_num; /* DIF block number Video: 0-134, Audio: 0-8 */
return 3; return 3;
} }
...@@ -6420,18 +6423,18 @@ static inline int dv_write_dif_id(enum dv_section_type t, uint8_t chan_num, uint ...@@ -6420,18 +6423,18 @@ static inline int dv_write_dif_id(enum dv_section_type t, uint8_t chan_num, uint
static inline int dv_write_ssyb_id(uint8_t syb_num, uint8_t fr, uint8_t* buf) static inline int dv_write_ssyb_id(uint8_t syb_num, uint8_t fr, uint8_t* buf)
{ {
if (syb_num == 0 || syb_num == 6) { if (syb_num == 0 || syb_num == 6) {
buf[0] = (fr<<7) | /* FR ID 1 - first half of each channel; 0 - second */ buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
(0<<4) | /* AP3 (Subcode application ID) */ (0 << 4) | /* AP3 (Subcode application ID) */
0x0f; /* reserved -- always 1 */ 0x0f; /* reserved -- always 1 */
} }
else if (syb_num == 11) { else if (syb_num == 11) {
buf[0] = (fr<<7) | /* FR ID 1 - first half of each channel; 0 - second */ buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
0x7f; /* reserved -- always 1 */ 0x7f; /* reserved -- always 1 */
} }
else { else {
buf[0] = (fr<<7) | /* FR ID 1 - first half of each channel; 0 - second */ buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
(0<<4) | /* APT (Track application ID) */ (0 << 4) | /* APT (Track application ID) */
0x0f; /* reserved -- always 1 */ 0x0f; /* reserved -- always 1 */
} }
buf[1] = 0xf0 | /* reserved -- always 1 */ buf[1] = 0xf0 | /* reserved -- always 1 */
(syb_num & 0x0f); /* SSYB number 0 - 11 */ (syb_num & 0x0f); /* SSYB number 0 - 11 */
......
libavformat/dv.c
View file @ f94036f1
...@@ -35,14 +35,14 @@ ...@@ -35,14 +35,14 @@
struct DVDemuxContext { struct DVDemuxContext {
const DVprofile* sys; /* Current DV profile. E.g.: 525/60, 625/50 */ const DVprofile* sys; /* Current DV profile. E.g.: 525/60, 625/50 */
AVFormatContext* fctx; AVFormatContext* fctx;
AVStream* vst; AVStream* vst;
AVStream* ast[4]; AVStream* ast[4];
AVPacket audio_pkt[4]; AVPacket audio_pkt[4];
uint8_t audio_buf[4][8192]; uint8_t audio_buf[4][8192];
int ach; int ach;
int frames; int frames;
uint64_t abytes; uint64_t abytes;
}; };
static inline uint16_t dv_audio_12to16(uint16_t sample) static inline uint16_t dv_audio_12to16(uint16_t sample)
...@@ -50,7 +50,7 @@ static inline uint16_t dv_audio_12to16(uint16_t sample) ...@@ -50,7 +50,7 @@ static inline uint16_t dv_audio_12to16(uint16_t sample)
uint16_t shift, result; uint16_t shift, result;
sample = (sample < 0x800) ? sample : sample | 0xf000; sample = (sample < 0x800) ? sample : sample | 0xf000;
shift = (sample & 0xf00) >> 8; shift = (sample & 0xf00) >> 8;
if (shift < 0x2 || shift > 0xd) { if (shift < 0x2 || shift > 0xd) {
result = sample; result = sample;
...@@ -76,16 +76,16 @@ static const uint8_t* dv_extract_pack(uint8_t* frame, enum dv_pack_type t) ...@@ -76,16 +76,16 @@ static const uint8_t* dv_extract_pack(uint8_t* frame, enum dv_pack_type t)
switch (t) { switch (t) {
case dv_audio_source: case dv_audio_source:
offs = (80*6 + 80*16*3 + 3); offs = (80*6 + 80*16*3 + 3);
break; break;
case dv_audio_control: case dv_audio_control:
offs = (80*6 + 80*16*4 + 3); offs = (80*6 + 80*16*4 + 3);
break; break;
case dv_video_control: case dv_video_control:
offs = (80*5 + 48 + 5); offs = (80*5 + 48 + 5);
break; break;
default: default:
return NULL; return NULL;
} }
return frame[offs] == t ? &frame[offs] : NULL; return frame[offs] == t ? &frame[offs] : NULL;
...@@ -111,20 +111,20 @@ static int dv_extract_audio(uint8_t* frame, uint8_t* ppcm[4], ...@@ -111,20 +111,20 @@ static int dv_extract_audio(uint8_t* frame, uint8_t* ppcm[4],
if (!as_pack) /* No audio ? */ if (!as_pack) /* No audio ? */
return 0; return 0;
smpls = as_pack[1] & 0x3f; /* samples in this frame - min. samples */ smpls = as_pack[1] & 0x3f; /* samples in this frame - min. samples */
freq = (as_pack[4] >> 3) & 0x07; /* 0 - 48kHz, 1 - 44,1kHz, 2 - 32kHz */ freq = (as_pack[4] >> 3) & 0x07; /* 0 - 48kHz, 1 - 44,1kHz, 2 - 32kHz */
quant = as_pack[4] & 0x07; /* 0 - 16bit linear, 1 - 12bit nonlinear */ quant = as_pack[4] & 0x07; /* 0 - 16bit linear, 1 - 12bit nonlinear */
if (quant > 1) if (quant > 1)
return -1; /* unsupported quantization */ return -1; /* unsupported quantization */
size = (sys->audio_min_samples[freq] + smpls) * 4; /* 2ch, 2bytes */ size = (sys->audio_min_samples[freq] + smpls) * 4; /* 2ch, 2bytes */
half_ch = sys->difseg_size/2; half_ch = sys->difseg_size / 2;
/* We work with 720p frames split in half, thus even frames have /* We work with 720p frames split in half, thus even frames have
* channels 0,1 and odd 2,3 */ * channels 0,1 and odd 2,3. */
ipcm = (sys->height == 720 && !(frame[1]&0x0C))?2:0; ipcm = (sys->height == 720 && !(frame[1] & 0x0C)) ? 2 : 0;
pcm = ppcm[ipcm++]; pcm = ppcm[ipcm++];
/* for each DIF channel */ /* for each DIF channel */
for (chan = 0; chan < sys->n_difchan; chan++) { for (chan = 0; chan < sys->n_difchan; chan++) {
...@@ -142,7 +142,7 @@ static int dv_extract_audio(uint8_t* frame, uint8_t* ppcm[4], ...@@ -142,7 +142,7 @@ static int dv_extract_audio(uint8_t* frame, uint8_t* ppcm[4],
for (j = 0; j < 9; j++) { for (j = 0; j < 9; j++) {
for (d = 8; d < 80; d += 2) { for (d = 8; d < 80; d += 2) {
if (quant == 0) { /* 16bit quantization */ if (quant == 0) { /* 16bit quantization */
of = sys->audio_shuffle[i][j] + (d - 8)/2 * sys->audio_stride; of = sys->audio_shuffle[i][j] + (d - 8) / 2 * sys->audio_stride;
if (of*2 >= size) if (of*2 >= size)
continue; continue;
...@@ -151,21 +151,21 @@ static int dv_extract_audio(uint8_t* frame, uint8_t* ppcm[4], ...@@ -151,21 +151,21 @@ static int dv_extract_audio(uint8_t* frame, uint8_t* ppcm[4],
if (pcm[of*2+1] == 0x80 && pcm[of*2] == 0x00) if (pcm[of*2+1] == 0x80 && pcm[of*2] == 0x00)
pcm[of*2+1] = 0; pcm[of*2+1] = 0;
} else { /* 12bit quantization */ } else { /* 12bit quantization */
lc = ((uint16_t)frame[d] << 4) | lc = ((uint16_t)frame[d] << 4) |
((uint16_t)frame[d+2] >> 4); ((uint16_t)frame[d+2] >> 4);
rc = ((uint16_t)frame[d+1] << 4) | rc = ((uint16_t)frame[d+1] << 4) |
((uint16_t)frame[d+2] & 0x0f); ((uint16_t)frame[d+2] & 0x0f);
lc = (lc == 0x800 ? 0 : dv_audio_12to16(lc)); lc = (lc == 0x800 ? 0 : dv_audio_12to16(lc));
rc = (rc == 0x800 ? 0 : dv_audio_12to16(rc)); rc = (rc == 0x800 ? 0 : dv_audio_12to16(rc));
of = sys->audio_shuffle[i%half_ch][j] + (d - 8)/3 * sys->audio_stride; of = sys->audio_shuffle[i%half_ch][j] + (d - 8) / 3 * sys->audio_stride;
if (of*2 >= size) if (of*2 >= size)
continue; continue;
pcm[of*2] = lc & 0xff; // FIXME: maybe we have to admit pcm[of*2] = lc & 0xff; // FIXME: maybe we have to admit
pcm[of*2+1] = lc >> 8; // that DV is a big-endian PCM pcm[of*2+1] = lc >> 8; // that DV is a big-endian PCM
of = sys->audio_shuffle[i%half_ch+half_ch][j] + of = sys->audio_shuffle[i%half_ch+half_ch][j] +
(d - 8)/3 * sys->audio_stride; (d - 8) / 3 * sys->audio_stride;
pcm[of*2] = rc & 0xff; // FIXME: maybe we have to admit pcm[of*2] = rc & 0xff; // FIXME: maybe we have to admit
pcm[of*2+1] = rc >> 8; // that DV is a big-endian PCM pcm[of*2+1] = rc >> 8; // that DV is a big-endian PCM
++d; ++d;
...@@ -196,10 +196,10 @@ static int dv_extract_audio_info(DVDemuxContext* c, uint8_t* frame) ...@@ -196,10 +196,10 @@ static int dv_extract_audio_info(DVDemuxContext* c, uint8_t* frame)
return 0; return 0;
} }
smpls = as_pack[1] & 0x3f; /* samples in this frame - min. samples */ smpls = as_pack[1] & 0x3f; /* samples in this frame - min. samples */
freq = (as_pack[4] >> 3) & 0x07; /* 0 - 48kHz, 1 - 44,1kHz, 2 - 32kHz */ freq = (as_pack[4] >> 3) & 0x07; /* 0 - 48kHz, 1 - 44,1kHz, 2 - 32kHz */
stype = (as_pack[3] & 0x1f); /* 0 - 2CH, 2 - 4CH, 3 - 8CH */ stype = (as_pack[3] & 0x1f); /* 0 - 2CH, 2 - 4CH, 3 - 8CH */
quant = as_pack[4] & 0x07; /* 0 - 16bit linear, 1 - 12bit nonlinear */ quant = as_pack[4] & 0x07; /* 0 - 16bit linear, 1 - 12bit nonlinear */
/* note: ach counts PAIRS of channels (i.e. stereo channels) */ /* note: ach counts PAIRS of channels (i.e. stereo channels) */
ach = ((int[4]){ 1, 0, 2, 4})[stype]; ach = ((int[4]){ 1, 0, 2, 4})[stype];
...@@ -207,25 +207,25 @@ static int dv_extract_audio_info(DVDemuxContext* c, uint8_t* frame) ...@@ -207,25 +207,25 @@ static int dv_extract_audio_info(DVDemuxContext* c, uint8_t* frame)
ach = 2; ach = 2;
/* Dynamic handling of the audio streams in DV */ /* Dynamic handling of the audio streams in DV */
for (i=0; i<ach; i++) { for (i = 0; i < ach; i++) {
if (!c->ast[i]) { if (!c->ast[i]) {
c->ast[i] = av_new_stream(c->fctx, 0); c->ast[i] = av_new_stream(c->fctx, 0);
if (!c->ast[i]) if (!c->ast[i])
break; break;
av_set_pts_info(c->ast[i], 64, 1, 30000); av_set_pts_info(c->ast[i], 64, 1, 30000);
c->ast[i]->codec->codec_type = CODEC_TYPE_AUDIO; c->ast[i]->codec->codec_type = CODEC_TYPE_AUDIO;
c->ast[i]->codec->codec_id = CODEC_ID_PCM_S16LE; c->ast[i]->codec->codec_id = CODEC_ID_PCM_S16LE;
av_init_packet(&c->audio_pkt[i]); av_init_packet(&c->audio_pkt[i]);
c->audio_pkt[i].size = 0; c->audio_pkt[i].size = 0;
c->audio_pkt[i].data = c->audio_buf[i]; c->audio_pkt[i].data = c->audio_buf[i];
c->audio_pkt[i].stream_index = c->ast[i]->index; c->audio_pkt[i].stream_index = c->ast[i]->index;
c->audio_pkt[i].flags |= PKT_FLAG_KEY; c->audio_pkt[i].flags |= PKT_FLAG_KEY;
} }
c->ast[i]->codec->sample_rate = dv_audio_frequency[freq]; c->ast[i]->codec->sample_rate = dv_audio_frequency[freq];
c->ast[i]->codec->channels = 2; c->ast[i]->codec->channels = 2;
c->ast[i]->codec->bit_rate = 2 * dv_audio_frequency[freq] * 16; c->ast[i]->codec->bit_rate = 2 * dv_audio_frequency[freq] * 16;
c->ast[i]->start_time = 0; c->ast[i]->start_time = 0;
} }
c->ach = i; c->ach = i;
...@@ -242,9 +242,10 @@ static int dv_extract_video_info(DVDemuxContext *c, uint8_t* frame) ...@@ -242,9 +242,10 @@ static int dv_extract_video_info(DVDemuxContext *c, uint8_t* frame)
if (c->sys) { if (c->sys) {
avctx = c->vst->codec; avctx = c->vst->codec;
av_set_pts_info(c->vst, 64, c->sys->time_base.num, c->sys->time_base.den); av_set_pts_info(c->vst, 64, c->sys->time_base.num,
c->sys->time_base.den);
avctx->time_base= c->sys->time_base; avctx->time_base= c->sys->time_base;
if(!avctx->width){ if (!avctx->width){
avctx->width = c->sys->width; avctx->width = c->sys->width;
avctx->height = c->sys->height; avctx->height = c->sys->height;
} }
...@@ -252,9 +253,9 @@ static int dv_extract_video_info(DVDemuxContext *c, uint8_t* frame) ...@@ -252,9 +253,9 @@ static int dv_extract_video_info(DVDemuxContext *c, uint8_t* frame)
/* finding out SAR is a little bit messy */ /* finding out SAR is a little bit messy */
vsc_pack = dv_extract_pack(frame, dv_video_control); vsc_pack = dv_extract_pack(frame, dv_video_control);
apt = frame[4] & 0x07; apt = frame[4] & 0x07;
is16_9 = (vsc_pack && ((vsc_pack[2] & 0x07) == 0x02 || is16_9 = (vsc_pack && ((vsc_pack[2] & 0x07) == 0x02 ||
(!apt && (vsc_pack[2] & 0x07) == 0x07))); (!apt && (vsc_pack[2] & 0x07) == 0x07)));
c->vst->sample_aspect_ratio = c->sys->sar[is16_9]; c->vst->sample_aspect_ratio = c->sys->sar[is16_9];
avctx->bit_rate = av_rescale_q(c->sys->frame_size, (AVRational){8,1}, avctx->bit_rate = av_rescale_q(c->sys->frame_size, (AVRational){8,1},
c->sys->time_base); c->sys->time_base);
...@@ -281,17 +282,17 @@ DVDemuxContext* dv_init_demux(AVFormatContext *s) ...@@ -281,17 +282,17 @@ DVDemuxContext* dv_init_demux(AVFormatContext *s)
return NULL; return NULL;
} }
c->sys = NULL; c->sys = NULL;
c->fctx = s; c->fctx = s;
memset(c->ast, 0, sizeof(c->ast)); memset(c->ast, 0, sizeof(c->ast));
c->ach = 0; c->ach = 0;
c->frames = 0; c->frames = 0;
c->abytes = 0; c->abytes = 0;
c->vst->codec->codec_type = CODEC_TYPE_VIDEO; c->vst->codec->codec_type = CODEC_TYPE_VIDEO;
c->vst->codec->codec_id = CODEC_ID_DVVIDEO; c->vst->codec->codec_id = CODEC_ID_DVVIDEO;
c->vst->codec->bit_rate = 25000000; c->vst->codec->bit_rate = 25000000;
c->vst->start_time = 0; c->vst->start_time = 0;
return c; return c;
} }
...@@ -301,7 +302,7 @@ int dv_get_packet(DVDemuxContext *c, AVPacket *pkt) ...@@ -301,7 +302,7 @@ int dv_get_packet(DVDemuxContext *c, AVPacket *pkt)
int size = -1; int size = -1;
int i; int i;
for (i=0; i<c->ach; i++) { for (i = 0; i < c->ach; i++) {
if (c->ast[i] && c->audio_pkt[i].size) { if (c->ast[i] && c->audio_pkt[i].size) {
*pkt = c->audio_pkt[i]; *pkt = c->audio_pkt[i];
c->audio_pkt[i].size = 0; c->audio_pkt[i].size = 0;
...@@ -328,7 +329,7 @@ int dv_produce_packet(DVDemuxContext *c, AVPacket *pkt, ...@@ -328,7 +329,7 @@ int dv_produce_packet(DVDemuxContext *c, AVPacket *pkt,
/* Queueing audio packet */ /* Queueing audio packet */
/* FIXME: in case of no audio/bad audio we have to do something */ /* FIXME: in case of no audio/bad audio we have to do something */
size = dv_extract_audio_info(c, buf); size = dv_extract_audio_info(c, buf);
for (i=0; i<c->ach; i++) { for (i = 0; i < c->ach; i++) {
c->audio_pkt[i].size = size; c->audio_pkt[i].size = size;
c->audio_pkt[i].pts = c->abytes * 30000*8 / c->ast[i]->codec->bit_rate; c->audio_pkt[i].pts = c->abytes * 30000*8 / c->ast[i]->codec->bit_rate;
ppcm[i] = c->audio_buf[i]; ppcm[i] = c->audio_buf[i];
...@@ -339,7 +340,7 @@ int dv_produce_packet(DVDemuxContext *c, AVPacket *pkt, ...@@ -339,7 +340,7 @@ int dv_produce_packet(DVDemuxContext *c, AVPacket *pkt,
/* We work with 720p frames split in half, thus even frames have /* We work with 720p frames split in half, thus even frames have
* channels 0,1 and odd 2,3. */ * channels 0,1 and odd 2,3. */
if (c->sys->height == 720) { if (c->sys->height == 720) {
if (buf[1]&0x0C) if (buf[1] & 0x0C)
c->audio_pkt[2].size = c->audio_pkt[3].size = 0; c->audio_pkt[2].size = c->audio_pkt[3].size = 0;
else else
c->audio_pkt[0].size = c->audio_pkt[1].size = 0; c->audio_pkt[0].size = c->audio_pkt[1].size = 0;
...@@ -348,11 +349,11 @@ int dv_produce_packet(DVDemuxContext *c, AVPacket *pkt, ...@@ -348,11 +349,11 @@ int dv_produce_packet(DVDemuxContext *c, AVPacket *pkt,
/* Now it's time to return video packet */ /* Now it's time to return video packet */
size = dv_extract_video_info(c, buf); size = dv_extract_video_info(c, buf);
av_init_packet(pkt); av_init_packet(pkt);
pkt->data = buf; pkt->data = buf;
pkt->size = size; pkt->size = size;
pkt->flags |= PKT_FLAG_KEY; pkt->flags |= PKT_FLAG_KEY;
pkt->stream_index = c->vst->id; pkt->stream_index = c->vst->id;
pkt->pts = c->frames; pkt->pts = c->frames;
c->frames++; c->frames++;
...@@ -442,14 +443,14 @@ static int dv_read_packet(AVFormatContext *s, AVPacket *pkt) ...@@ -442,14 +443,14 @@ static int dv_read_packet(AVFormatContext *s, AVPacket *pkt)
static int dv_read_seek(AVFormatContext *s, int stream_index, static int dv_read_seek(AVFormatContext *s, int stream_index,
int64_t timestamp, int flags) int64_t timestamp, int flags)
{ {
RawDVContext *r = s->priv_data; RawDVContext *r = s->priv_data;
DVDemuxContext *c = r->dv_demux; DVDemuxContext *c = r->dv_demux;
int64_t offset= dv_frame_offset(s, c, timestamp, flags); int64_t offset = dv_frame_offset(s, c, timestamp, flags);
dv_offset_reset(c, offset / c->sys->frame_size); dv_offset_reset(c, offset / c->sys->frame_size);
offset = url_fseek(s->pb, offset, SEEK_SET); offset = url_fseek(s->pb, offset, SEEK_SET);
return (offset < 0)?offset:0; return (offset < 0) ? offset : 0;
} }
static int dv_read_close(AVFormatContext *s) static int dv_read_close(AVFormatContext *s)
......
libavformat/dvenc.c
View file @ f94036f1
...@@ -38,12 +38,12 @@ struct DVMuxContext { ...@@ -38,12 +38,12 @@ struct DVMuxContext {
const DVprofile* sys; /* current DV profile, e.g.: 525/60, 625/50 */ const DVprofile* sys; /* current DV profile, e.g.: 525/60, 625/50 */
int n_ast; /* number of stereo audio streams (up to 2) */ int n_ast; /* number of stereo audio streams (up to 2) */
AVStream *ast[2]; /* stereo audio streams */ AVStream *ast[2]; /* stereo audio streams */
AVFifoBuffer audio_data[2]; /* FIFO for storing excessive amounts of PCM */ AVFifoBuffer audio_data[2]; /* FIFO for storing excessive amounts of PCM */
int frames; /* current frame number */ int frames; /* current frame number */
time_t start_time; /* recording start time */ time_t start_time; /* recording start time */
int has_audio; /* frame under contruction has audio */ int has_audio; /* frame under contruction has audio */
int has_video; /* frame under contruction has video */ int has_video; /* frame under contruction has video */
uint8_t frame_buf[DV_MAX_FRAME_SIZE]; /* frame under contruction */ uint8_t frame_buf[DV_MAX_FRAME_SIZE]; /* frame under contruction */
}; };
static const int dv_aaux_packs_dist[12][9] = { static const int dv_aaux_packs_dist[12][9] = {
...@@ -63,7 +63,7 @@ static const int dv_aaux_packs_dist[12][9] = { ...@@ -63,7 +63,7 @@ static const int dv_aaux_packs_dist[12][9] = {
static int dv_audio_frame_size(const DVprofile* sys, int frame) static int dv_audio_frame_size(const DVprofile* sys, int frame)
{ {
return sys->audio_samples_dist[frame % (sizeof(sys->audio_samples_dist)/ return sys->audio_samples_dist[frame % (sizeof(sys->audio_samples_dist) /
sizeof(sys->audio_samples_dist[0]))]; sizeof(sys->audio_samples_dist[0]))];
} }
...@@ -77,14 +77,14 @@ static int dv_write_pack(enum dv_pack_type pack_id, DVMuxContext *c, uint8_t* bu ...@@ -77,14 +77,14 @@ static int dv_write_pack(enum dv_pack_type pack_id, DVMuxContext *c, uint8_t* bu
buf[0] = (uint8_t)pack_id; buf[0] = (uint8_t)pack_id;
switch (pack_id) { switch (pack_id) {
case dv_timecode: case dv_timecode:
ct = (time_t)av_rescale_rnd(c->frames, c->sys->time_base.num, c->sys->time_base.den, ct = (time_t)av_rescale_rnd(c->frames, c->sys->time_base.num,
AV_ROUND_DOWN); c->sys->time_base.den, AV_ROUND_DOWN);
brktimegm(ct, &tc); brktimegm(ct, &tc);
/* /*
* LTC drop-frame frame counter drops two frames (0 and 1) every * LTC drop-frame frame counter drops two frames (0 and 1) every
* minute, unless it is exactly divisible by 10 * minute, unless it is exactly divisible by 10
*/ */
ltc_frame = (c->frames + 2*ct/60 - 2*ct/600) % c->sys->ltc_divisor; ltc_frame = (c->frames + 2 * ct / 60 - 2 * ct / 600) % c->sys->ltc_divisor;
buf[1] = (0 << 7) | /* color frame: 0 - unsync; 1 - sync mode */ buf[1] = (0 << 7) | /* color frame: 0 - unsync; 1 - sync mode */
(1 << 6) | /* drop frame timecode: 0 - nondrop; 1 - drop */ (1 << 6) | /* drop frame timecode: 0 - nondrop; 1 - drop */
((ltc_frame / 10) << 4) | /* tens of frames */ ((ltc_frame / 10) << 4) | /* tens of frames */
...@@ -132,14 +132,14 @@ static int dv_write_pack(enum dv_pack_type pack_id, DVMuxContext *c, uint8_t* bu ...@@ -132,14 +132,14 @@ static int dv_write_pack(enum dv_pack_type pack_id, DVMuxContext *c, uint8_t* bu
7; 7;
buf[3] = (1 << 7) | /* direction: 1 -- forward */ buf[3] = (1 << 7) | /* direction: 1 -- forward */
(c->sys->pix_fmt == PIX_FMT_YUV420P ? 0x20 : /* speed */ (c->sys->pix_fmt == PIX_FMT_YUV420P ? 0x20 : /* speed */
c->sys->ltc_divisor*4); c->sys->ltc_divisor * 4);
buf[4] = (1 << 7) | /* reserved -- always 1 */ buf[4] = (1 << 7) | /* reserved -- always 1 */
0x7f; /* genre category */ 0x7f; /* genre category */
break; break;
case dv_audio_recdate: case dv_audio_recdate:
case dv_video_recdate: /* VAUX recording date */ case dv_video_recdate: /* VAUX recording date */
ct = c->start_time + av_rescale_rnd(c->frames, c->sys->time_base.num, ct = c->start_time + av_rescale_rnd(c->frames, c->sys->time_base.num,
c->sys->time_base.den, AV_ROUND_DOWN); c->sys->time_base.den, AV_ROUND_DOWN);
brktimegm(ct, &tc); brktimegm(ct, &tc);
buf[1] = 0xff; /* ds, tm, tens of time zone, units of time zone */ buf[1] = 0xff; /* ds, tm, tens of time zone, units of time zone */
/* 0xff is very likely to be "unknown" */ /* 0xff is very likely to be "unknown" */
...@@ -264,10 +264,10 @@ int dv_assemble_frame(DVMuxContext *c, AVStream* st, ...@@ -264,10 +264,10 @@ int dv_assemble_frame(DVMuxContext *c, AVStream* st,
} }
/* Let us see if we have enough data to construct one DV frame. */ /* Let us see if we have enough data to construct one DV frame. */
if (c->has_video == 1 && c->has_audio + 1 == 1<<c->n_ast) { if (c->has_video == 1 && c->has_audio + 1 == 1 << c->n_ast) {
dv_inject_metadata(c, *frame); dv_inject_metadata(c, *frame);
c->has_audio = 0; c->has_audio = 0;
for (i=0; i<c->n_ast; i++) { for (i=0; i < c->n_ast; i++) {
dv_inject_audio(c, i, *frame); dv_inject_audio(c, i, *frame);
av_fifo_drain(&c->audio_data[i], reqasize); av_fifo_drain(&c->audio_data[i], reqasize);
c->has_audio |= ((reqasize <= av_fifo_size(&c->audio_data[i])) << i); c->has_audio |= ((reqasize <= av_fifo_size(&c->audio_data[i])) << i);
...@@ -293,7 +293,7 @@ DVMuxContext* dv_init_mux(AVFormatContext* s) ...@@ -293,7 +293,7 @@ DVMuxContext* dv_init_mux(AVFormatContext* s)
if (s->nb_streams > 3) if (s->nb_streams > 3)
return NULL; return NULL;
c->n_ast = 0; c->n_ast = 0;
c->ast[0] = c->ast[1] = NULL; c->ast[0] = c->ast[1] = NULL;
/* We have to sort out where audio and where video stream is */ /* We have to sort out where audio and where video stream is */
...@@ -316,29 +316,29 @@ DVMuxContext* dv_init_mux(AVFormatContext* s) ...@@ -316,29 +316,29 @@ DVMuxContext* dv_init_mux(AVFormatContext* s)
if (!vst || vst->codec->codec_id != CODEC_ID_DVVIDEO) if (!vst || vst->codec->codec_id != CODEC_ID_DVVIDEO)
goto bail_out; goto bail_out;
for (i=0; i<c->n_ast; i++) { for (i=0; i<c->n_ast; i++) {
if (c->ast[i] && (c->ast[i]->codec->codec_id != CODEC_ID_PCM_S16LE || if (c->ast[i] && (c->ast[i]->codec->codec_id != CODEC_ID_PCM_S16LE ||
c->ast[i]->codec->sample_rate != 48000 || c->ast[i]->codec->sample_rate != 48000 ||
c->ast[i]->codec->channels != 2)) c->ast[i]->codec->channels != 2))
goto bail_out; goto bail_out;
} }
c->sys = dv_codec_profile(vst->codec); c->sys = dv_codec_profile(vst->codec);
if (!c->sys) if (!c->sys)
goto bail_out; goto bail_out;
if((c->n_ast > 1) && (c->sys->n_difchan < 2)) { if ((c->n_ast > 1) && (c->sys->n_difchan < 2)) {
/* only 1 stereo pair is allowed in 25Mbps mode */ /* only 1 stereo pair is allowed in 25Mbps mode */
goto bail_out; goto bail_out;
} }
/* Ok, everything seems to be in working order */ /* Ok, everything seems to be in working order */
c->frames = 0; c->frames = 0;
c->has_audio = 0; c->has_audio = 0;
c->has_video = 0; c->has_video = 0;
c->start_time = (time_t)s->timestamp; c->start_time = (time_t)s->timestamp;
for (i=0; i<c->n_ast; i++) { for (i=0; i < c->n_ast; i++) {
if (c->ast[i] && av_fifo_init(&c->audio_data[i], 100*AVCODEC_MAX_AUDIO_FRAME_SIZE) < 0) { if (c->ast[i] && av_fifo_init(&c->audio_data[i], 100*AVCODEC_MAX_AUDIO_FRAME_SIZE) < 0) {
while (i>0) { while (i > 0) {
i--; i--;
av_fifo_free(&c->audio_data[i]); av_fifo_free(&c->audio_data[i]);
} }
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment