[FFmpeg-cvslog] r15682 - in trunk: libavcodec/dv.c libavcodec/dvdata.h libavformat/dv.c libavformat/dvenc.c
diego
subversion
Fri Oct 24 23:41:27 CEST 2008
Author: diego
Date: Fri Oct 24 23:41:27 2008
New Revision: 15682
Log:
prettyprinting cosmetics
Modified:
trunk/libavcodec/dv.c
trunk/libavcodec/dvdata.h
trunk/libavformat/dv.c
trunk/libavformat/dvenc.c
Modified: trunk/libavcodec/dv.c
==============================================================================
--- trunk/libavcodec/dv.c (original)
+++ trunk/libavcodec/dv.c Fri Oct 24 23:41:27 2008
@@ -48,12 +48,12 @@
//#include <assert.h>
typedef struct DVVideoContext {
- const DVprofile* sys;
- AVFrame picture;
- AVCodecContext *avctx;
- uint8_t *buf;
+ const DVprofile *sys;
+ AVFrame picture;
+ AVCodecContext *avctx;
+ 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 dv100_idct_factor[4][4][16][64];
@@ -94,29 +94,29 @@ static void dv_build_unquantize_tables(D
int i, q, a;
/* NOTE: max left shift is 6 */
- for(q = 0; q < 22; q++) {
+ for (q = 0; q < 22; q++) {
/* 88DCT */
- i=1;
- for(a = 0; a<4; a++) {
- for(; i < dv_quant_areas[a]; i++) {
+ i = 1;
+ for (a = 0; a < 4; a++) {
+ for (; i < dv_quant_areas[a]; i++) {
/* 88 table */
- 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[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;
/* 248 table */
- 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[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;
}
}
}
- for(a = 0; a < 4; a++) {
- for(q = 0; q < 16; q++) {
- 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[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[3][a][q][i]= (dv100_qstep[q]<<(a+9))*dv_iweight_720_c[i];
+ for (a = 0; a < 4; a++) {
+ for (q = 0; q < 16; q++) {
+ 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[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[3][a][q][i] = (dv100_qstep[q] << (a + 9)) * dv_iweight_720_c[i];
}
}
}
@@ -126,27 +126,27 @@ static av_cold int dvvideo_init(AVCodecC
{
DVVideoContext *s = avctx->priv_data;
DSPContext dsp;
- static int done=0;
+ static int done = 0;
int i, j;
if (!done) {
VLC dv_vlc;
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_run[NB_DV_VLC*2];
- int16_t new_dv_vlc_level[NB_DV_VLC*2];
+ uint8_t new_dv_vlc_len[NB_DV_VLC*2];
+ uint8_t new_dv_vlc_run[NB_DV_VLC*2];
+ int16_t new_dv_vlc_level[NB_DV_VLC*2];
done = 1;
/* 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;
/* it's faster to include sign bit in a generic VLC parsing scheme */
- for (i=0, j=0; i<NB_DV_VLC; i++, j++) {
- new_dv_vlc_bits[j] = dv_vlc_bits[i];
- new_dv_vlc_len[j] = dv_vlc_len[i];
- new_dv_vlc_run[j] = dv_vlc_run[i];
+ for (i = 0, j = 0; i < NB_DV_VLC; i++, j++) {
+ new_dv_vlc_bits[j] = dv_vlc_bits[i];
+ new_dv_vlc_len[j] = dv_vlc_len[i];
+ new_dv_vlc_run[j] = dv_vlc_run[i];
new_dv_vlc_level[j] = dv_vlc_level[i];
if (dv_vlc_level[i]) {
@@ -154,9 +154,9 @@ static av_cold int dvvideo_init(AVCodecC
new_dv_vlc_len[j]++;
j++;
- new_dv_vlc_bits[j] = (dv_vlc_bits[i] << 1) | 1;
- new_dv_vlc_len[j] = dv_vlc_len[i] + 1;
- new_dv_vlc_run[j] = dv_vlc_run[i];
+ new_dv_vlc_bits[j] = (dv_vlc_bits[i] << 1) | 1;
+ new_dv_vlc_len[j] = dv_vlc_len[i] + 1;
+ new_dv_vlc_run[j] = dv_vlc_run[i];
new_dv_vlc_level[j] = -dv_vlc_level[i];
}
}
@@ -167,21 +167,21 @@ static av_cold int dvvideo_init(AVCodecC
new_dv_vlc_len, 1, 1, new_dv_vlc_bits, 2, 2, 0);
assert(dv_vlc.table_size == 1184);
- for(i = 0; i < dv_vlc.table_size; i++){
- int code= dv_vlc.table[i][0];
- int len = dv_vlc.table[i][1];
+ for (i = 0; i < dv_vlc.table_size; i++){
+ int code = dv_vlc.table[i][0];
+ int len = dv_vlc.table[i][1];
int level, run;
- if(len<0){ //more bits needed
- run= 0;
- level= code;
+ if (len < 0){ //more bits needed
+ run = 0;
+ level = code;
} else {
- run= new_dv_vlc_run[code] + 1;
- level= new_dv_vlc_level[code];
+ run = new_dv_vlc_run [code] + 1;
+ 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].run = run;
+ dv_rl_vlc[i].run = run;
}
free_vlc(&dv_vlc);
@@ -196,10 +196,10 @@ static av_cold int dvvideo_init(AVCodecC
if (dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].size != 0)
continue;
- dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].vlc = 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_level[i]);
+ dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].vlc =
+ 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_level[i]);
}
for (i = 0; i < DV_VLC_MAP_RUN_SIZE; i++) {
#ifdef DV_CODEC_TINY_TARGET
@@ -233,18 +233,18 @@ static av_cold int dvvideo_init(AVCodecC
s->get_pixels = dsp.get_pixels;
/* 88DCT setup */
- s->fdct[0] = dsp.fdct;
+ s->fdct[0] = dsp.fdct;
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]];
/* 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
- if(avctx->lowres){
- for (i=0; i<64; i++){
- int j= ff_zigzag248_direct[i];
- s->dv_zigzag[1][i] = dsp.idct_permutation[(j&7) + (j&8)*4 + (j&48)/2];
+ if (avctx->lowres){
+ for (i = 0; i < 64; i++){
+ int j = ff_zigzag248_direct[i];
+ s->dv_zigzag[1][i] = dsp.idct_permutation[(j & 7) + (j & 8) * 4 + (j & 48) / 2];
}
}else
memcpy(s->dv_zigzag[1], ff_zigzag248_direct, 64);
@@ -253,7 +253,7 @@ static av_cold int dvvideo_init(AVCodecC
dv_build_unquantize_tables(s, dsp.idct_permutation);
avctx->coded_frame = &s->picture;
- s->avctx= avctx;
+ s->avctx = avctx;
return 0;
}
@@ -290,9 +290,9 @@ static inline int put_bits_left(PutBitCo
static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, DCTELEM *block)
{
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;
- int pos = mb->pos;
+ int pos = mb->pos;
int partial_bit_count = mb->partial_bit_count;
int level, run, vlc_len, index;
@@ -302,25 +302,25 @@ static void dv_decode_ac(GetBitContext *
/* if we must parse a partial vlc, we do it here */
if (partial_bit_count > 0) {
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;
mb->partial_bit_count = 0;
}
/* get the AC coefficients until last_index is reached */
- for(;;) {
+ for (;;) {
#ifdef VLC_DEBUG
printf("%2d: bits=%04x index=%d\n", pos, SHOW_UBITS(re, gb, 16), re_index);
#endif
/* 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;
if (vlc_len < 0) {
index = NEG_USR32((unsigned)re_cache << TEX_VLC_BITS, -vlc_len) + dv_rl_vlc[index].level;
vlc_len = TEX_VLC_BITS - vlc_len;
}
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 */
if (re_index + vlc_len > last_index) {
@@ -339,7 +339,7 @@ static void dv_decode_ac(GetBitContext *
if (pos >= 64)
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;
UPDATE_CACHE(re, gb);
@@ -362,7 +362,7 @@ static inline void bit_copy(PutBitContex
/* mb_x and mb_y are in units of 8 pixels */
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)
{
int quant, dc, dct_mode, class1, j;
@@ -378,43 +378,43 @@ static inline void dv_decode_video_segme
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, 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];
- assert((((int)mb_bit_buffer)&7)==0);
- assert((((int)vs_bit_buffer)&7)==0);
+ assert((((int)mb_bit_buffer) & 7) == 0);
+ assert((((int)vs_bit_buffer) & 7) == 0);
memset(sblock, 0, sizeof(sblock));
/* pass 1 : read DC and AC coefficients in blocks */
buf_ptr = buf_ptr1;
- block1 = &sblock[0][0];
- mb1 = mb_data;
+ block1 = &sblock[0][0];
+ mb1 = mb_data;
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 */
quant = buf_ptr[3] & 0x0f;
buf_ptr += 4;
init_put_bits(&pb, mb_bit_buffer, 80);
- mb = mb1;
+ mb = mb1;
block = block1;
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];
init_get_bits(&gb, buf_ptr, last_index);
/* get the dc */
- dc = get_sbits(&gb, 9);
+ dc = get_sbits(&gb, 9);
dct_mode = get_bits1(&gb);
- class1 = get_bits(&gb, 2);
+ class1 = get_bits(&gb, 2);
if (DV_PROFILE_IS_HD(s->sys)) {
- mb->idct_put = s->idct_put[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->idct_put = s->idct_put[0];
+ mb->scan_table = s->dv_zigzag[0];
+ mb->factor_table = s->dv100_idct_factor[((s->sys->height == 720) << 1) | (j >= 4)][class1][quant];
is_field_mode[mb_index] |= !j && dct_mode;
} else {
- mb->idct_put = s->idct_put[dct_mode && log2_blocksize==3];
- mb->scan_table = s->dv_zigzag[dct_mode];
+ mb->idct_put = s->idct_put[dct_mode && log2_blocksize == 3];
+ mb->scan_table = s->dv_zigzag[dct_mode];
mb->factor_table = s->dv_idct_factor[class1 == 3][dct_mode]
[quant + dv_quant_offset[class1]];
}
@@ -424,7 +424,7 @@ static inline void dv_decode_video_segme
dc += 1024;
block[0] = dc;
buf_ptr += last_index >> 3;
- mb->pos = 0;
+ mb->pos = 0;
mb->partial_bit_count = 0;
#ifdef VLC_DEBUG
@@ -446,10 +446,10 @@ static inline void dv_decode_video_segme
printf("***pass 2 size=%d MB#=%d\n", put_bits_count(&pb), mb_index);
#endif
block = block1;
- mb = mb1;
+ mb = mb1;
init_get_bits(&gb, mb_bit_buffer, put_bits_count(&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) {
dv_decode_ac(&gb, mb, block);
/* if still not finished, no need to parse other blocks */
@@ -468,11 +468,11 @@ static inline void dv_decode_video_segme
printf("***pass 3 size=%d\n", put_bits_count(&vs_pb));
#endif
block = &sblock[0][0];
- mb = mb_data;
+ mb = mb_data;
init_get_bits(&gb, vs_bit_buffer, put_bits_count(&vs_pb));
flush_put_bits(&vs_pb);
- for(mb_index = 0; mb_index < 5; mb_index++) {
- for(j = 0;j < s->sys->bpm; j++) {
+ for (mb_index = 0; mb_index < 5; mb_index++) {
+ for (j = 0; j < s->sys->bpm; j++) {
if (mb->pos < 64) {
#ifdef VLC_DEBUG
printf("start %d:%d\n", mb_index, j);
@@ -488,41 +488,41 @@ static inline void dv_decode_video_segme
/* compute idct and place blocks */
block = &sblock[0][0];
- mb = mb_data;
- for(mb_index = 0; mb_index < 5; mb_index++) {
+ mb = mb_data;
+ for (mb_index = 0; mb_index < 5; mb_index++) {
v = *mb_pos_ptr++;
mb_x = v & 0xff;
mb_y = v >> 8;
/* 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)) {
- mb_y -= (mb_y>17)?18:-72; /* shifting the Y coordinate down by 72/2 macroblocks */
+ 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 */
}
/* idct_put'ting luminance */
if ((s->sys->pix_fmt == PIX_FMT_YUV420P) ||
(s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
(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 {
- 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);
- linesize = s->picture.linesize[0]<<is_field_mode[mb_index];
- mb[0] .idct_put(y_ptr , linesize, block + 0*64);
+ 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];
+ mb[0] .idct_put(y_ptr , linesize, block + 0*64);
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 {
- 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[3].idct_put(y_ptr + (1<<log2_blocksize) + y_stride, linesize, block + 3*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[3].idct_put(y_ptr + (1 << log2_blocksize) + y_stride, linesize, block + 3*64);
}
mb += 4;
block += 4*64;
/* idct_put'ting chrominance */
- 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);
- for(j=2; j; j--) {
+ 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);
+ for (j = 2; j; j--) {
uint8_t *c_ptr = s->picture.data[j] + c_offset;
if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
uint64_t aligned_pixels[64/8];
@@ -530,22 +530,22 @@ static inline void dv_decode_video_segme
uint8_t *c_ptr1, *ptr1;
int x, y;
mb->idct_put(pixels, 8, block);
- for(y = 0; y < (1<<log2_blocksize); y++, c_ptr += s->picture.linesize[j], pixels += 8) {
- ptr1= pixels + (1<<(log2_blocksize-1));
- c_ptr1 = c_ptr + (s->picture.linesize[j]<<log2_blocksize);
- for(x=0; x < (1<<(log2_blocksize-1)); x++) {
- c_ptr[x]= pixels[x];
- c_ptr1[x]= ptr1[x];
+ for (y = 0; y < (1 << log2_blocksize); y++, c_ptr += s->picture.linesize[j], pixels += 8) {
+ ptr1 = pixels + (1 << (log2_blocksize - 1));
+ c_ptr1 = c_ptr + (s->picture.linesize[j] << log2_blocksize);
+ for (x = 0; x < (1 << (log2_blocksize - 1)); x++) {
+ c_ptr[x] = pixels[x];
+ c_ptr1[x] = ptr1[x];
}
}
block += 64; mb++;
} else {
- y_stride = (mb_y == 134) ? (1<<log2_blocksize) :
- s->picture.linesize[j]<<((!is_field_mode[mb_index])*log2_blocksize);
- linesize = s->picture.linesize[j]<<is_field_mode[mb_index];
- (mb++)-> idct_put(c_ptr , linesize, block); block+=64;
+ y_stride = (mb_y == 134) ? (1 << log2_blocksize) :
+ s->picture.linesize[j] << ((!is_field_mode[mb_index]) * log2_blocksize);
+ linesize = s->picture.linesize[j] << is_field_mode[mb_index];
+ (mb++)-> idct_put(c_ptr , linesize, block); block += 64;
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(in
if (run) {
*vlc |= ((run < 16) ? dv_vlc_map[run-1][0].vlc :
(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_si
#endif
typedef struct EncBlockInfo {
- int area_q[4];
- int bit_size[4];
- int prev[5];
- int cur_ac;
- int cno;
- int dct_mode;
- DCTELEM mb[64];
- uint8_t next[64];
- uint8_t sign[64];
- uint8_t partial_bit_count;
+ int area_q[4];
+ int bit_size[4];
+ int prev[5];
+ int cur_ac;
+ int cno;
+ int dct_mode;
+ DCTELEM mb[64];
+ uint8_t next[64];
+ uint8_t sign[64];
+ uint8_t partial_bit_count;
uint32_t partial_bit_buffer; /* we can't use uint16_t here */
} EncBlockInfo;
-static av_always_inline PutBitContext* dv_encode_ac(EncBlockInfo* bi, PutBitContext* pb_pool,
- PutBitContext* pb_end)
+static av_always_inline PutBitContext* dv_encode_ac(EncBlockInfo* bi,
+ PutBitContext* pb_pool,
+ PutBitContext* pb_end)
{
- int prev;
- int bits_left;
+ int prev, bits_left;
PutBitContext* pb = pb_pool;
int size = bi->partial_bit_count;
uint32_t vlc = bi->partial_bit_buffer;
bi->partial_bit_count = bi->partial_bit_buffer = 0;
- for(;;){
+ for (;;){
/* Find suitable storage space */
for (; size > (bits_left = put_bits_left(pb)); pb++) {
if (bits_left) {
size -= bits_left;
put_bits(pb, bits_left, vlc >> size);
- vlc = vlc & ((1<<size)-1);
+ vlc = vlc & ((1 << size) - 1);
}
if (pb + 1 >= pb_end) {
- bi->partial_bit_count = size;
+ bi->partial_bit_count = size;
bi->partial_bit_buffer = vlc;
return pb;
}
@@ -649,13 +649,13 @@ static av_always_inline PutBitContext* d
/* Store VLC */
put_bits(pb, size, vlc);
- if(bi->cur_ac>=64)
+ if (bi->cur_ac >= 64)
break;
/* Construct the next VLC */
- prev= bi->cur_ac;
+ prev = bi->cur_ac;
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);
} else {
size = 4; vlc = 6; /* End Of Block stamp */
@@ -665,7 +665,8 @@ static av_always_inline PutBitContext* d
}
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;
/* We offer two different methods for class number assignment: the
@@ -683,50 +684,51 @@ static av_always_inline void dv_set_clas
#else /* improved FFmpeg method */
static const int classes[] = {-1, -1, 255, 0xffff};
#endif
- int max=classes[0];
- int prev=0;
+ int max = classes[0];
+ int prev = 0;
bi->mb[0] = blk[0];
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 :)
- 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]];
- if (level+15 > 30U) {
- bi->sign[i] = (level>>31)&1;
+ if (level + 15 > 30U) {
+ bi->sign[i] = (level >> 31) & 1;
/* 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
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;
- if(level>max) max= level;
+ if (level > max)
+ max = level;
bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, level);
bi->next[prev]= i;
- prev= i;
+ 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;
if (bi->cno >= 3) {
bi->cno = 3;
- prev=0;
- i= bi->next[prev];
+ prev = 0;
+ i = bi->next[prev];
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 :)
- for (; i<mb_area_start[area+1]; i= bi->next[i]) {
- bi->mb[i] >>=1;
+ for (; i < mb_area_start[area+1]; i = bi->next[i]) {
+ bi->mb[i] >>= 1;
if (bi->mb[i]) {
bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]);
bi->next[prev]= i;
- prev= i;
+ prev = i;
}
}
}
@@ -738,20 +740,20 @@ static av_always_inline void dv_set_clas
#define SC(x, y) ((s[x] - s[y]) ^ ((s[x] - s[y]) >> 7))
static av_always_inline int dv_guess_dct_mode(DCTELEM *blk) {
DCTELEM *s;
- int score88 = 0;
+ int score88 = 0;
int score248 = 0;
int i;
/* Compute 8-8 score (small values give a better chance for 8-8 DCT) */
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) +
SC(4, 12) + SC(5,13) + SC(6, 14) + SC(7, 15);
s += 8;
}
/* Compute 2-4-8 score (small values give a better chance for 2-4-8 DCT) */
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) +
SC(4, 20) + SC(5,21) + SC(6, 22) + SC(7, 23);
s += 8;
@@ -766,36 +768,36 @@ static inline void dv_guess_qnos(EncBloc
int i, j, k, a, prev, a2;
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 {
b = blks;
- for (i=0; i<5; i++) {
+ for (i = 0; i < 5; i++) {
if (!qnos[i])
continue;
qnos[i]--;
size[i] = 0;
- for (j=0; j<6; j++, b++) {
- for (a=0; a<4; a++) {
+ for (j = 0; j < 6; j++, b++) {
+ for (a = 0; a < 4; 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->area_q[a]++;
- prev= b->prev[a];
+ prev = b->prev[a];
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;
if (b->mb[k]) {
b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
- prev= k;
+ prev = k;
} else {
- 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++)
+ 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++)
b->prev[a2] = prev;
- assert(a2<4);
+ assert(a2 < 4);
assert(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]]);
- 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->next[prev] = b->next[k];
@@ -806,23 +808,23 @@ static inline void dv_guess_qnos(EncBloc
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;
}
} 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;
- size[0] = 5*6*4; //EOB
- for (j=0; j<6*5; j++, b++) {
- prev= b->prev[0];
- for (k= b->next[prev]; k<64; k= b->next[k]) {
- if(b->mb[k] < a && b->mb[k] > -a){
+ size[0] = 5 * 6 * 4; //EOB
+ for (j = 0; j < 6 *5; j++, b++) {
+ prev = b->prev[0];
+ for (k = b->next[prev]; k < 64; k = b->next[k]) {
+ if (b->mb[k] < a && b->mb[k] > -a){
b->next[prev] = b->next[k];
}else{
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_segme
enc_blk = &enc_blks[0];
pb = &pbs[0];
- for(mb_index = 0; mb_index < 5; mb_index++) {
- v = *mb_pos_ptr++;
- mb_x = v & 0xff;
- mb_y = v >> 8;
- 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] +
- (mb_x>>((s->sys->pix_fmt == PIX_FMT_YUV411P)?2:1)))<<3);
- do_edge_wrap = 0;
+ for (mb_index = 0; mb_index < 5; mb_index++) {
+ v = *mb_pos_ptr++;
+ mb_x = v & 0xff;
+ mb_y = v >> 8;
+ 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] +
+ (mb_x >> ((s->sys->pix_fmt == PIX_FMT_YUV411P) ? 2 : 1))) << 3);
+ do_edge_wrap = 0;
qnos[mb_index] = 15; /* No quantization */
ptr = dif + mb_index*80 + 4;
- for(j = 0;j < 6; j++) {
+ for (j = 0; j < 6; j++) {
int dummy = 0;
if (s->sys->pix_fmt == PIX_FMT_YUV422P) { /* 4:2:2 */
if (j == 0 || j == 2) {
/* Y0 Y1 */
- data = y_ptr + ((j>>1) * 8);
+ data = y_ptr + ((j >> 1) * 8);
linesize = s->picture.linesize[0];
} else if (j > 3) {
/* Cr Cb */
- data = s->picture.data[6 - j] + c_offset;
+ data = s->picture.data[6 - j] + c_offset;
linesize = s->picture.linesize[6 - j];
} else {
/* j=1 and j=3 are "dummy" blocks, used for AC data only */
- data = 0;
+ data = 0;
linesize = 0;
- dummy = 1;
+ dummy = 1;
}
} else { /* 4:1:1 or 4:2:0 */
if (j < 4) { /* Four Y blocks */
@@ -889,7 +891,7 @@ static inline void dv_encode_video_segme
linesize = s->picture.linesize[0];
} else { /* Cr and Cb blocks */
/* 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];
if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8))
do_edge_wrap = 1;
@@ -900,7 +902,7 @@ static inline void dv_encode_video_segme
if (do_edge_wrap) { /* Edge wrap copy: 4x16 -> 8x8 */
uint8_t* d;
DCTELEM *b = block;
- for (i=0;i<8;i++) {
+ for (i = 0; i < 8; i++) {
d = data + 8 * linesize;
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];
@@ -912,7 +914,7 @@ static inline void dv_encode_video_segme
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);
else
enc_blk->dct_mode = 0;
@@ -950,33 +952,33 @@ static inline void dv_encode_video_segme
if (vs_total_ac_bits < vs_bit_size)
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];
}
/* 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]);
/* Second pass over each MB space */
- for (j=0; j<5*6; j+=6) {
- pb= &pbs[j];
- for (i=0; i<6; i++) {
+ for (j = 0; j < 5 * 6; j += 6) {
+ pb = &pbs[j];
+ for (i = 0; i < 6; i++) {
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 */
- pb= &pbs[0];
- for (j=0; j<5*6; j++) {
+ pb = &pbs[0];
+ for (j = 0; j < 5 * 6; j++) {
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)
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]);
}
@@ -1002,8 +1004,10 @@ static int dv_decode_mt(AVCodecContext *
(DV_PROFILE_IS_720p50(s->sys) && seq > 9))
return 0;
- dv_decode_video_segment(s, &s->buf[(seq*6+(chan_slice/3)+chan_slice*5+7)*80 + chan_offset],
- &s->sys->video_place[slice*5]);
+ dv_decode_video_segment(s, &s->buf[(seq * 6 + (chan_slice / 3)
+ + chan_slice * 5 + 7)
+ * 80 + chan_offset],
+ &s->sys->video_place[slice * 5]);
return 0;
}
@@ -1022,8 +1026,10 @@ static int dv_encode_mt(AVCodecContext *
/* byte offset of this channel's data */
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],
- &s->sys->video_place[slice*5]);
+ dv_encode_video_segment(s, &s->buf[((chan_slice / 27) * 6 + (chan_slice / 3)
+ + chan_slice * 5 + 7)
+ * 80 + chan_offset],
+ &s->sys->video_place[slice * 5]);
return 0;
}
#endif
@@ -1041,21 +1047,21 @@ static int dvvideo_decode_frame(AVCodecC
if (!s->sys || buf_size < s->sys->frame_size)
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);
s->picture.reference = 0;
s->picture.key_frame = 1;
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;
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");
return -1;
}
s->picture.interlaced_frame = 1;
- s->picture.top_field_first = 0;
+ s->picture.top_field_first = 0;
s->buf = buf;
avctx->execute(avctx, dv_decode_mt, (void**)&dv_anchor[0], NULL,
@@ -1065,14 +1071,15 @@ static int dvvideo_decode_frame(AVCodecC
/* return image */
*data_size = sizeof(AVFrame);
- *(AVFrame*)data= s->picture;
+ *(AVFrame*)data = s->picture;
return s->sys->frame_size;
}
#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:
@@ -1092,51 +1099,51 @@ static inline int dv_write_pack(enum dv_
* 2. It is not at all clear what STYPE is used for 4:2:0 PAL
* 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);
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;
buf[0] = (uint8_t)pack_id;
switch (pack_id) {
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 */
- buf[1] = 0xf8 | /* reserved -- always 1 */
- (apt & 0x07); /* APT: Track application ID */
- buf[2] = (0 << 7) | /* TF1: audio data is 0 - valid; 1 - invalid */
+ buf[1] = 0xf8 | /* reserved -- always 1 */
+ (apt & 0x07); /* APT: Track application ID */
+ buf[2] = (0 << 7) | /* TF1: audio data is 0 - valid; 1 - invalid */
(0x0f << 3) | /* reserved -- always 1 */
(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 */
(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 */
(apt & 0x07); /* AP3: Subcode application ID */
break;
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 */
(1 << 6) | /* following CLF is valid - 0, invalid - 1 */
(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 */
(c->sys->dsf << 5) | /* system: 60fields/50fields */
- stype; /* signal type video compression */
- buf[4] = 0xff; /* VISC: 0xff -- no information */
+ stype; /* signal type video compression */
+ buf[4] = 0xff; /* VISC: 0xff -- no information */
break;
case dv_video_control:
buf[1] = (0 << 6) | /* Copy generation management (CGMS) 0 -- free */
- 0x3f; /* reserved -- always 1 */
- buf[2] = 0xc8 | /* reserved -- always b11001xxx */
+ 0x3f; /* reserved -- always 1 */
+ buf[2] = 0xc8 | /* reserved -- always b11001xxx */
aspect;
buf[3] = (1 << 7) | /* frame/field flag 1 -- frame, 0 -- field */
(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 << 4) | /* 1 - interlaced, 0 - noninterlaced */
- 0xc; /* reserved -- always b1100 */
- buf[4] = 0xff; /* reserved -- always 1 */
+ 0xc; /* reserved -- always b1100 */
+ buf[4] = 0xff; /* reserved -- always 1 */
break;
default:
buf[1] = buf[2] = buf[3] = buf[4] = 0xff;
@@ -1203,11 +1210,11 @@ static int dvvideo_encode_frame(AVCodecC
s->sys = dv_codec_profile(c);
if (!s->sys)
return -1;
- if(buf_size < s->sys->frame_size)
+ if (buf_size < s->sys->frame_size)
return -1;
- c->pix_fmt = s->sys->pix_fmt;
- s->picture = *((AVFrame *)data);
+ c->pix_fmt = s->sys->pix_fmt;
+ s->picture = *((AVFrame *)data);
s->picture.key_frame = 1;
s->picture.pict_type = FF_I_TYPE;
@@ -1227,7 +1234,7 @@ static int dvvideo_close(AVCodecContext
{
DVVideoContext *s = c->priv_data;
- if(s->picture.data[0])
+ if (s->picture.data[0])
c->release_buffer(c, &s->picture);
return 0;
@@ -1242,7 +1249,7 @@ AVCodec dvvideo_encoder = {
sizeof(DVVideoContext),
dvvideo_init,
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)"),
};
#endif // CONFIG_DVVIDEO_ENCODER
Modified: trunk/libavcodec/dvdata.h
==============================================================================
--- trunk/libavcodec/dvdata.h (original)
+++ trunk/libavcodec/dvdata.h Fri Oct 24 23:41:27 2008
@@ -37,26 +37,26 @@
* DV specs as well (e.g. SMPTE314M vs. IEC 61834).
*/
typedef struct DVprofile {
- int dsf; /* value of the dsf in the DV header */
- int video_stype; /* stype for VAUX source pack */
- int frame_size; /* total size of one frame in bytes */
- int difseg_size; /* number of DIF segments per DIF channel */
- int n_difchan; /* number of DIF channels per frame */
- AVRational time_base; /* 1/framerate */
- int ltc_divisor; /* FPS from the LTS standpoint */
- int height; /* picture height in pixels */
- int width; /* picture width in pixels */
- AVRational sar[2]; /* sample aspect ratios for 4:3 and 16:9 */
- const uint16_t *video_place; /* positions of all DV macroblocks */
- enum PixelFormat pix_fmt; /* picture pixel format */
- int bpm; /* blocks per macroblock */
- const uint8_t *block_sizes; /* AC block sizes, in bits */
- int audio_stride; /* size of audio_shuffle table */
- int audio_min_samples[3];/* min amount of audio samples */
- /* for 48kHz, 44.1kHz and 32kHz */
- int audio_samples_dist[5];/* how many samples are supposed to be */
- /* in each frame in a 5 frames window */
- const uint8_t (*audio_shuffle)[9]; /* PCM shuffling table */
+ int dsf; /* value of the dsf in the DV header */
+ int video_stype; /* stype for VAUX source pack */
+ int frame_size; /* total size of one frame in bytes */
+ int difseg_size; /* number of DIF segments per DIF channel */
+ int n_difchan; /* number of DIF channels per frame */
+ AVRational time_base; /* 1/framerate */
+ int ltc_divisor; /* FPS from the LTS standpoint */
+ int height; /* picture height in pixels */
+ int width; /* picture width in pixels */
+ AVRational sar[2]; /* sample aspect ratios for 4:3 and 16:9 */
+ const uint16_t *video_place; /* positions of all DV macroblocks */
+ enum PixelFormat pix_fmt; /* picture pixel format */
+ int bpm; /* blocks per macroblock */
+ const uint8_t *block_sizes; /* AC block sizes, in bits */
+ int audio_stride; /* size of audio_shuffle table */
+ int audio_min_samples[3]; /* min amount of audio samples */
+ /* for 48kHz, 44.1kHz and 32kHz */
+ int audio_samples_dist[5]; /* how many samples are supposed to be */
+ /* in each frame in a 5 frames window */
+ const uint8_t (*audio_shuffle)[9]; /* PCM shuffling table */
} DVprofile;
#define NB_DV_VLC 409
@@ -232,38 +232,38 @@ static const uint8_t dv_vlc_run[409] = {
};
static const uint8_t dv_vlc_level[409] = {
- 1, 2, 1, 3, 4, 1, 2, 5,
- 6, 1, 1, 7, 8, 1, 1, 2,
- 3, 4, 9, 10, 11, 1, 1, 1,
- 1, 2, 2, 3, 5, 6, 7, 12,
- 13, 14, 15, 16, 17, 1, 1, 1,
- 1, 2, 2, 3, 3, 4, 5, 8,
- 18, 19, 20, 21, 22, 3, 4, 5,
- 6, 9, 10, 11, 0, 0, 3, 4,
- 6, 12, 13, 14, 0, 0, 0, 0,
- 2, 2, 2, 2, 3, 3, 5, 7,
- 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, 1, 2, 3, 4, 5, 6, 7,
- 8, 9, 10, 11, 12, 13, 14, 15,
- 16, 17, 18, 19, 20, 21, 22, 23,
- 24, 25, 26, 27, 28, 29, 30, 31,
- 32, 33, 34, 35, 36, 37, 38, 39,
- 40, 41, 42, 43, 44, 45, 46, 47,
- 48, 49, 50, 51, 52, 53, 54, 55,
- 56, 57, 58, 59, 60, 61, 62, 63,
- 64, 65, 66, 67, 68, 69, 70, 71,
- 72, 73, 74, 75, 76, 77, 78, 79,
- 80, 81, 82, 83, 84, 85, 86, 87,
- 88, 89, 90, 91, 92, 93, 94, 95,
- 96, 97, 98, 99, 100, 101, 102, 103,
+ 1, 2, 1, 3, 4, 1, 2, 5,
+ 6, 1, 1, 7, 8, 1, 1, 2,
+ 3, 4, 9, 10, 11, 1, 1, 1,
+ 1, 2, 2, 3, 5, 6, 7, 12,
+ 13, 14, 15, 16, 17, 1, 1, 1,
+ 1, 2, 2, 3, 3, 4, 5, 8,
+ 18, 19, 20, 21, 22, 3, 4, 5,
+ 6, 9, 10, 11, 0, 0, 3, 4,
+ 6, 12, 13, 14, 0, 0, 0, 0,
+ 2, 2, 2, 2, 3, 3, 5, 7,
+ 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, 1, 2, 3, 4, 5, 6, 7,
+ 8, 9, 10, 11, 12, 13, 14, 15,
+ 16, 17, 18, 19, 20, 21, 22, 23,
+ 24, 25, 26, 27, 28, 29, 30, 31,
+ 32, 33, 34, 35, 36, 37, 38, 39,
+ 40, 41, 42, 43, 44, 45, 46, 47,
+ 48, 49, 50, 51, 52, 53, 54, 55,
+ 56, 57, 58, 59, 60, 61, 62, 63,
+ 64, 65, 66, 67, 68, 69, 70, 71,
+ 72, 73, 74, 75, 76, 77, 78, 79,
+ 80, 81, 82, 83, 84, 85, 86, 87,
+ 88, 89, 90, 91, 92, 93, 94, 95,
+ 96, 97, 98, 99, 100, 101, 102, 103,
104, 105, 106, 107, 108, 109, 110, 111,
112, 113, 114, 115, 116, 117, 118, 119,
120, 121, 122, 123, 124, 125, 126, 127,
@@ -283,7 +283,7 @@ static const uint8_t dv_vlc_level[409] =
232, 233, 234, 235, 236, 237, 238, 239,
240, 241, 242, 243, 244, 245, 246, 247,
248, 249, 250, 251, 252, 253, 254, 255,
- 0,
+ 0,
};
/* unquant tables (not used directly) */
@@ -312,8 +312,8 @@ static const uint8_t dv_quant_shifts[22]
{ 0,0,0,0 },
};
-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_offset[4] = { 6, 3, 0, 1 };
+static const uint8_t dv_quant_areas[4] = { 6, 21, 43, 64 };
/* quantization quanta by QNO for DV100 */
static const uint8_t dv100_qstep[16] = {
@@ -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_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 */
/**
@@ -6398,21 +6399,23 @@ static const DVprofile* dv_codec_profile
int 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 &&
- codec->width == dv_profiles[i].width)
+ if (codec->height == dv_profiles[i].height &&
+ codec->pix_fmt == dv_profiles[i].pix_fmt &&
+ codec->width == dv_profiles[i].width)
return &dv_profiles[i];
return NULL;
}
-static inline int dv_write_dif_id(enum dv_section_type t, uint8_t chan_num, uint8_t seq_num,
- uint8_t dif_num, uint8_t* buf)
+static inline int dv_write_dif_id(enum dv_section_type t, uint8_t chan_num,
+ uint8_t seq_num, uint8_t dif_num,
+ uint8_t* buf)
{
- 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[0] = (uint8_t)t; /* Section type */
+ 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 */
- 7; /* reserved -- always 1 */
- buf[2] = dif_num; /* DIF block number Video: 0-134, Audio: 0-8 */
+ 7; /* reserved -- always 1 */
+ buf[2] = dif_num; /* DIF block number Video: 0-134, Audio: 0-8 */
return 3;
}
@@ -6420,18 +6423,18 @@ static inline int dv_write_dif_id(enum d
static inline int dv_write_ssyb_id(uint8_t syb_num, uint8_t fr, uint8_t* buf)
{
if (syb_num == 0 || syb_num == 6) {
- buf[0] = (fr<<7) | /* FR ID 1 - first half of each channel; 0 - second */
- (0<<4) | /* AP3 (Subcode application ID) */
- 0x0f; /* reserved -- always 1 */
+ buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
+ (0 << 4) | /* AP3 (Subcode application ID) */
+ 0x0f; /* reserved -- always 1 */
}
else if (syb_num == 11) {
- buf[0] = (fr<<7) | /* FR ID 1 - first half of each channel; 0 - second */
- 0x7f; /* reserved -- always 1 */
+ buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
+ 0x7f; /* reserved -- always 1 */
}
else {
- buf[0] = (fr<<7) | /* FR ID 1 - first half of each channel; 0 - second */
- (0<<4) | /* APT (Track application ID) */
- 0x0f; /* reserved -- always 1 */
+ buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
+ (0 << 4) | /* APT (Track application ID) */
+ 0x0f; /* reserved -- always 1 */
}
buf[1] = 0xf0 | /* reserved -- always 1 */
(syb_num & 0x0f); /* SSYB number 0 - 11 */
Modified: trunk/libavformat/dv.c
==============================================================================
--- trunk/libavformat/dv.c (original)
+++ trunk/libavformat/dv.c Fri Oct 24 23:41:27 2008
@@ -35,14 +35,14 @@
struct DVDemuxContext {
const DVprofile* sys; /* Current DV profile. E.g.: 525/60, 625/50 */
- AVFormatContext* fctx;
- AVStream* vst;
- AVStream* ast[4];
- AVPacket audio_pkt[4];
- uint8_t audio_buf[4][8192];
- int ach;
- int frames;
- uint64_t abytes;
+ AVFormatContext* fctx;
+ AVStream* vst;
+ AVStream* ast[4];
+ AVPacket audio_pkt[4];
+ uint8_t audio_buf[4][8192];
+ int ach;
+ int frames;
+ uint64_t abytes;
};
static inline uint16_t dv_audio_12to16(uint16_t sample)
@@ -50,7 +50,7 @@ static inline uint16_t dv_audio_12to16(u
uint16_t shift, result;
sample = (sample < 0x800) ? sample : sample | 0xf000;
- shift = (sample & 0xf00) >> 8;
+ shift = (sample & 0xf00) >> 8;
if (shift < 0x2 || shift > 0xd) {
result = sample;
@@ -76,16 +76,16 @@ static const uint8_t* dv_extract_pack(ui
switch (t) {
case dv_audio_source:
- offs = (80*6 + 80*16*3 + 3);
- break;
+ offs = (80*6 + 80*16*3 + 3);
+ break;
case dv_audio_control:
- offs = (80*6 + 80*16*4 + 3);
- break;
+ offs = (80*6 + 80*16*4 + 3);
+ break;
case dv_video_control:
- offs = (80*5 + 48 + 5);
- break;
+ offs = (80*5 + 48 + 5);
+ break;
default:
- return NULL;
+ return NULL;
}
return frame[offs] == t ? &frame[offs] : NULL;
@@ -111,20 +111,20 @@ static int dv_extract_audio(uint8_t* fra
if (!as_pack) /* No audio ? */
return 0;
- smpls = as_pack[1] & 0x3f; /* samples in this frame - min. samples */
- freq = (as_pack[4] >> 3) & 0x07; /* 0 - 48kHz, 1 - 44,1kHz, 2 - 32kHz */
- quant = as_pack[4] & 0x07; /* 0 - 16bit linear, 1 - 12bit nonlinear */
+ smpls = as_pack[1] & 0x3f; /* samples in this frame - min. samples */
+ freq = (as_pack[4] >> 3) & 0x07; /* 0 - 48kHz, 1 - 44,1kHz, 2 - 32kHz */
+ quant = as_pack[4] & 0x07; /* 0 - 16bit linear, 1 - 12bit nonlinear */
if (quant > 1)
return -1; /* unsupported quantization */
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
- * channels 0,1 and odd 2,3 */
- ipcm = (sys->height == 720 && !(frame[1]&0x0C))?2:0;
- pcm = ppcm[ipcm++];
+ * channels 0,1 and odd 2,3. */
+ ipcm = (sys->height == 720 && !(frame[1] & 0x0C)) ? 2 : 0;
+ pcm = ppcm[ipcm++];
/* for each DIF channel */
for (chan = 0; chan < sys->n_difchan; chan++) {
@@ -142,7 +142,7 @@ static int dv_extract_audio(uint8_t* fra
for (j = 0; j < 9; j++) {
for (d = 8; d < 80; d += 2) {
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)
continue;
@@ -151,21 +151,21 @@ static int dv_extract_audio(uint8_t* fra
if (pcm[of*2+1] == 0x80 && pcm[of*2] == 0x00)
pcm[of*2+1] = 0;
} else { /* 12bit quantization */
- lc = ((uint16_t)frame[d] << 4) |
+ lc = ((uint16_t)frame[d] << 4) |
((uint16_t)frame[d+2] >> 4);
rc = ((uint16_t)frame[d+1] << 4) |
((uint16_t)frame[d+2] & 0x0f);
lc = (lc == 0x800 ? 0 : dv_audio_12to16(lc));
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)
continue;
pcm[of*2] = lc & 0xff; // FIXME: maybe we have to admit
pcm[of*2+1] = lc >> 8; // that DV is a big-endian PCM
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+1] = rc >> 8; // that DV is a big-endian PCM
++d;
@@ -196,10 +196,10 @@ static int dv_extract_audio_info(DVDemux
return 0;
}
- smpls = as_pack[1] & 0x3f; /* samples in this frame - min. samples */
- freq = (as_pack[4] >> 3) & 0x07; /* 0 - 48kHz, 1 - 44,1kHz, 2 - 32kHz */
- stype = (as_pack[3] & 0x1f); /* 0 - 2CH, 2 - 4CH, 3 - 8CH */
- quant = as_pack[4] & 0x07; /* 0 - 16bit linear, 1 - 12bit nonlinear */
+ smpls = as_pack[1] & 0x3f; /* samples in this frame - min. samples */
+ freq = (as_pack[4] >> 3) & 0x07; /* 0 - 48kHz, 1 - 44,1kHz, 2 - 32kHz */
+ stype = (as_pack[3] & 0x1f); /* 0 - 2CH, 2 - 4CH, 3 - 8CH */
+ quant = as_pack[4] & 0x07; /* 0 - 16bit linear, 1 - 12bit nonlinear */
/* note: ach counts PAIRS of channels (i.e. stereo channels) */
ach = ((int[4]){ 1, 0, 2, 4})[stype];
@@ -207,25 +207,25 @@ static int dv_extract_audio_info(DVDemux
ach = 2;
/* Dynamic handling of the audio streams in DV */
- for (i=0; i<ach; i++) {
+ for (i = 0; i < ach; i++) {
if (!c->ast[i]) {
c->ast[i] = av_new_stream(c->fctx, 0);
if (!c->ast[i])
break;
av_set_pts_info(c->ast[i], 64, 1, 30000);
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]);
- c->audio_pkt[i].size = 0;
- c->audio_pkt[i].data = c->audio_buf[i];
+ c->audio_pkt[i].size = 0;
+ c->audio_pkt[i].data = c->audio_buf[i];
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->channels = 2;
- c->ast[i]->codec->bit_rate = 2 * dv_audio_frequency[freq] * 16;
- c->ast[i]->start_time = 0;
+ c->ast[i]->codec->channels = 2;
+ c->ast[i]->codec->bit_rate = 2 * dv_audio_frequency[freq] * 16;
+ c->ast[i]->start_time = 0;
}
c->ach = i;
@@ -242,9 +242,10 @@ static int dv_extract_video_info(DVDemux
if (c->sys) {
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;
- if(!avctx->width){
+ if (!avctx->width){
avctx->width = c->sys->width;
avctx->height = c->sys->height;
}
@@ -252,9 +253,9 @@ static int dv_extract_video_info(DVDemux
/* finding out SAR is a little bit messy */
vsc_pack = dv_extract_pack(frame, dv_video_control);
- apt = frame[4] & 0x07;
- is16_9 = (vsc_pack && ((vsc_pack[2] & 0x07) == 0x02 ||
- (!apt && (vsc_pack[2] & 0x07) == 0x07)));
+ apt = frame[4] & 0x07;
+ is16_9 = (vsc_pack && ((vsc_pack[2] & 0x07) == 0x02 ||
+ (!apt && (vsc_pack[2] & 0x07) == 0x07)));
c->vst->sample_aspect_ratio = c->sys->sar[is16_9];
avctx->bit_rate = av_rescale_q(c->sys->frame_size, (AVRational){8,1},
c->sys->time_base);
@@ -281,17 +282,17 @@ DVDemuxContext* dv_init_demux(AVFormatCo
return NULL;
}
- c->sys = NULL;
+ c->sys = NULL;
c->fctx = s;
memset(c->ast, 0, sizeof(c->ast));
- c->ach = 0;
+ c->ach = 0;
c->frames = 0;
c->abytes = 0;
c->vst->codec->codec_type = CODEC_TYPE_VIDEO;
- c->vst->codec->codec_id = CODEC_ID_DVVIDEO;
- c->vst->codec->bit_rate = 25000000;
- c->vst->start_time = 0;
+ c->vst->codec->codec_id = CODEC_ID_DVVIDEO;
+ c->vst->codec->bit_rate = 25000000;
+ c->vst->start_time = 0;
return c;
}
@@ -301,7 +302,7 @@ int dv_get_packet(DVDemuxContext *c, AVP
int size = -1;
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) {
*pkt = c->audio_pkt[i];
c->audio_pkt[i].size = 0;
@@ -328,7 +329,7 @@ int dv_produce_packet(DVDemuxContext *c,
/* Queueing audio packet */
/* FIXME: in case of no audio/bad audio we have to do something */
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].pts = c->abytes * 30000*8 / c->ast[i]->codec->bit_rate;
ppcm[i] = c->audio_buf[i];
@@ -339,7 +340,7 @@ int dv_produce_packet(DVDemuxContext *c,
/* We work with 720p frames split in half, thus even frames have
* channels 0,1 and odd 2,3. */
if (c->sys->height == 720) {
- if (buf[1]&0x0C)
+ if (buf[1] & 0x0C)
c->audio_pkt[2].size = c->audio_pkt[3].size = 0;
else
c->audio_pkt[0].size = c->audio_pkt[1].size = 0;
@@ -348,11 +349,11 @@ int dv_produce_packet(DVDemuxContext *c,
/* Now it's time to return video packet */
size = dv_extract_video_info(c, buf);
av_init_packet(pkt);
- pkt->data = buf;
- pkt->size = size;
- pkt->flags |= PKT_FLAG_KEY;
+ pkt->data = buf;
+ pkt->size = size;
+ pkt->flags |= PKT_FLAG_KEY;
pkt->stream_index = c->vst->id;
- pkt->pts = c->frames;
+ pkt->pts = c->frames;
c->frames++;
@@ -442,14 +443,14 @@ static int dv_read_packet(AVFormatContex
static int dv_read_seek(AVFormatContext *s, int stream_index,
int64_t timestamp, int flags)
{
- RawDVContext *r = s->priv_data;
+ RawDVContext *r = s->priv_data;
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);
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)
Modified: trunk/libavformat/dvenc.c
==============================================================================
--- trunk/libavformat/dvenc.c (original)
+++ trunk/libavformat/dvenc.c Fri Oct 24 23:41:27 2008
@@ -38,12 +38,12 @@ struct DVMuxContext {
const DVprofile* sys; /* current DV profile, e.g.: 525/60, 625/50 */
int n_ast; /* number of stereo audio streams (up to 2) */
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 */
time_t start_time; /* recording start time */
- int has_audio; /* frame under contruction has audio */
- int has_video; /* frame under contruction has video */
- uint8_t frame_buf[DV_MAX_FRAME_SIZE]; /* frame under contruction */
+ int has_audio; /* frame under contruction has audio */
+ int has_video; /* frame under contruction has video */
+ uint8_t frame_buf[DV_MAX_FRAME_SIZE]; /* frame under contruction */
};
static const int dv_aaux_packs_dist[12][9] = {
@@ -63,7 +63,7 @@ static const int dv_aaux_packs_dist[12][
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]))];
}
@@ -77,14 +77,14 @@ static int dv_write_pack(enum dv_pack_ty
buf[0] = (uint8_t)pack_id;
switch (pack_id) {
case dv_timecode:
- ct = (time_t)av_rescale_rnd(c->frames, c->sys->time_base.num, c->sys->time_base.den,
- AV_ROUND_DOWN);
+ ct = (time_t)av_rescale_rnd(c->frames, c->sys->time_base.num,
+ c->sys->time_base.den, AV_ROUND_DOWN);
brktimegm(ct, &tc);
/*
* LTC drop-frame frame counter drops two frames (0 and 1) every
* 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 */
(1 << 6) | /* drop frame timecode: 0 - nondrop; 1 - drop */
((ltc_frame / 10) << 4) | /* tens of frames */
@@ -132,14 +132,14 @@ static int dv_write_pack(enum dv_pack_ty
7;
buf[3] = (1 << 7) | /* direction: 1 -- forward */
(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 */
0x7f; /* genre category */
break;
case dv_audio_recdate:
case dv_video_recdate: /* VAUX recording date */
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);
buf[1] = 0xff; /* ds, tm, tens of time zone, units of time zone */
/* 0xff is very likely to be "unknown" */
@@ -264,10 +264,10 @@ int dv_assemble_frame(DVMuxContext *c, A
}
/* 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);
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);
av_fifo_drain(&c->audio_data[i], reqasize);
c->has_audio |= ((reqasize <= av_fifo_size(&c->audio_data[i])) << i);
@@ -293,7 +293,7 @@ DVMuxContext* dv_init_mux(AVFormatContex
if (s->nb_streams > 3)
return NULL;
- c->n_ast = 0;
+ c->n_ast = 0;
c->ast[0] = c->ast[1] = NULL;
/* We have to sort out where audio and where video stream is */
@@ -316,29 +316,29 @@ DVMuxContext* dv_init_mux(AVFormatContex
if (!vst || vst->codec->codec_id != CODEC_ID_DVVIDEO)
goto bail_out;
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->channels != 2))
+ c->ast[i]->codec->channels != 2))
goto bail_out;
}
c->sys = dv_codec_profile(vst->codec);
if (!c->sys)
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 */
goto bail_out;
}
/* Ok, everything seems to be in working order */
- c->frames = 0;
- c->has_audio = 0;
- c->has_video = 0;
+ c->frames = 0;
+ c->has_audio = 0;
+ c->has_video = 0;
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) {
- while (i>0) {
+ while (i > 0) {
i--;
av_fifo_free(&c->audio_data[i]);
}
More information about the ffmpeg-cvslog
mailing list