Chiebot-Mirror
/
FFmpeg
mirror of https://github.com/FFmpeg/FFmpeg.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

dv: K&R formatting cosmetics

Browse Source 
Signed-off-by: Diego Biurrun <diego@biurrun.de>
pull/88/head
Gabriel Dume 10 years ago committed by Diego Biurrun
parent f629705b02
commit ee0ebd3c14
7 changed files with 1029 additions and 989 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 237
      libavcodec/dv.c
  2. 73
      libavcodec/dv.h
  3. 389
      libavcodec/dv_profile.c
  4. 70
      libavcodec/dv_tablegen.h
  5. 494
      libavcodec/dvdata.c
  6. 162
      libavcodec/dvdec.c
  7. 593
      libavcodec/dvenc.c

237
libavcodec/dv.c
Unescape View File

@ -40,128 +40,135 @@
#include "libavutil/internal.h" #include "libavutil/internal.h"
#include "libavutil/pixdesc.h" #include "libavutil/pixdesc.h"
#include "avcodec.h" #include "avcodec.h"
#include "dv.h"
#include "dvdata.h"
#include "get_bits.h" #include "get_bits.h"
#include "internal.h" #include "internal.h"
#include "put_bits.h" #include "put_bits.h"
#include "simple_idct.h" #include "simple_idct.h"
#include "dvdata.h"
#include "dv.h"
/* XXX: also include quantization */ /* XXX: also include quantization */
RL_VLC_ELEM ff_dv_rl_vlc[1184]; RL_VLC_ELEM ff_dv_rl_vlc[1184];
static inline void dv_calc_mb_coordinates(const AVDVProfile *d, int chan, int seq, int slot, static inline void dv_calc_mb_coordinates(const AVDVProfile *d, int chan,
uint16_t *tbl) int seq, int slot, uint16_t *tbl)
{ {
static const uint8_t off[] = { 2, 6, 8, 0, 4 }; static const uint8_t off[] = { 2, 6, 8, 0, 4 };
static const uint8_t shuf1[] = { 36, 18, 54, 0, 72 }; static const uint8_t shuf1[] = { 36, 18, 54, 0, 72 };
static const uint8_t shuf2[] = { 24, 12, 36, 0, 48 }; static const uint8_t shuf2[] = { 24, 12, 36, 0, 48 };
static const uint8_t shuf3[] = { 18, 9, 27, 0, 36 }; static const uint8_t shuf3[] = { 18, 9, 27, 0, 36 };
static const uint8_t l_start[] = {0, 4, 9, 13, 18, 22, 27, 31, 36, 40}; static const uint8_t l_start[] = { 0, 4, 9, 13, 18, 22, 27, 31, 36, 40 };
static const uint8_t l_start_shuffled[] = { 9, 4, 13, 0, 18 }; static const uint8_t l_start_shuffled[] = { 9, 4, 13, 0, 18 };
static const uint8_t serpent1[] = {0, 1, 2, 2, 1, 0, static const uint8_t serpent1[] = {
0, 1, 2, 2, 1, 0, 0, 1, 2, 2, 1, 0,
0, 1, 2, 2, 1, 0, 0, 1, 2, 2, 1, 0,
0, 1, 2, 2, 1, 0, 0, 1, 2, 2, 1, 0,
0, 1, 2}; 0, 1, 2, 2, 1, 0,
static const uint8_t serpent2[] = {0, 1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 0, 0, 1, 2
0, 1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 0, };
0, 1, 2, 3, 4, 5}; static const uint8_t serpent2[] = {
0, 1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 0,
static const uint8_t remap[][2] = {{ 0, 0}, { 0, 0}, { 0, 0}, { 0, 0}, /* dummy */ 0, 1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 0,
{ 0, 0}, { 0, 1}, { 0, 2}, { 0, 3}, {10, 0}, 0, 1, 2, 3, 4, 5
{10, 1}, {10, 2}, {10, 3}, {20, 0}, {20, 1}, };
{20, 2}, {20, 3}, {30, 0}, {30, 1}, {30, 2},
{30, 3}, {40, 0}, {40, 1}, {40, 2}, {40, 3}, static const uint8_t remap[][2] = {
{50, 0}, {50, 1}, {50, 2}, {50, 3}, {60, 0}, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, /* dummy */
{60, 1}, {60, 2}, {60, 3}, {70, 0}, {70, 1}, { 0, 0 }, { 0, 1 }, { 0, 2 }, { 0, 3 }, { 10, 0 },
{70, 2}, {70, 3}, { 0,64}, { 0,65}, { 0,66}, { 10, 1 }, { 10, 2 }, { 10, 3 }, { 20, 0 }, { 20, 1 },
{10,64}, {10,65}, {10,66}, {20,64}, {20,65}, { 20, 2 }, { 20, 3 }, { 30, 0 }, { 30, 1 }, { 30, 2 },
{20,66}, {30,64}, {30,65}, {30,66}, {40,64}, { 30, 3 }, { 40, 0 }, { 40, 1 }, { 40, 2 }, { 40, 3 },
{40,65}, {40,66}, {50,64}, {50,65}, {50,66}, { 50, 0 }, { 50, 1 }, { 50, 2 }, { 50, 3 }, { 60, 0 },
{60,64}, {60,65}, {60,66}, {70,64}, {70,65}, { 60, 1 }, { 60, 2 }, { 60, 3 }, { 70, 0 }, { 70, 1 },
{70,66}, { 0,67}, {20,67}, {40,67}, {60,67}}; { 70, 2 }, { 70, 3 }, { 0, 64 }, { 0, 65 }, { 0, 66 },
{ 10, 64 }, { 10, 65 }, { 10, 66 }, { 20, 64 }, { 20, 65 },
{ 20, 66 }, { 30, 64 }, { 30, 65 }, { 30, 66 }, { 40, 64 },
{ 40, 65 }, { 40, 66 }, { 50, 64 }, { 50, 65 }, { 50, 66 },
{ 60, 64 }, { 60, 65 }, { 60, 66 }, { 70, 64 }, { 70, 65 },
{ 70, 66 }, { 0, 67 }, { 20, 67 }, { 40, 67 }, { 60, 67 }
};
int i, k, m; int i, k, m;
int x, y, blk; int x, y, blk;
for (m=0; m<5; m++) { for (m = 0; m < 5; m++) {
switch (d->width) { switch (d->width) {
case 1440: case 1440:
blk = (chan*11+seq)*27+slot; blk = (chan * 11 + seq) * 27 + slot;
if (chan == 0 && seq == 11) { if (chan == 0 && seq == 11) {
x = m*27+slot; x = m * 27 + slot;
if (x<90) { if (x < 90) {
y = 0; y = 0;
} else { } else {
x = (x - 90)*2; x = (x - 90) * 2;
y = 67; y = 67;
} }
} else { } else {
i = (4*chan + blk + off[m])%11; i = (4 * chan + blk + off[m]) % 11;
k = (blk/11)%27; k = (blk / 11) % 27;
x = shuf1[m] + (chan&1)*9 + k%9; x = shuf1[m] + (chan & 1) * 9 + k % 9;
y = (i*3+k/9)*2 + (chan>>1) + 1; y = (i * 3 + k / 9) * 2 + (chan >> 1) + 1;
} }
tbl[m] = (x<<1)|(y<<9); tbl[m] = (x << 1) | (y << 9);
break; break;
case 1280: case 1280:
blk = (chan*10+seq)*27+slot; blk = (chan * 10 + seq) * 27 + slot;
i = (4*chan + (seq/5) + 2*blk + off[m])%10; i = (4 * chan + (seq / 5) + 2 * blk + off[m]) % 10;
k = (blk/5)%27; k = (blk / 5) % 27;
x = shuf1[m]+(chan&1)*9 + k%9; x = shuf1[m] + (chan & 1) * 9 + k % 9;
y = (i*3+k/9)*2 + (chan>>1) + 4; y = (i * 3 + k / 9) * 2 + (chan >> 1) + 4;
if (x >= 80) { if (x >= 80) {
x = remap[y][0]+((x-80)<<(y>59)); x = remap[y][0] + ((x - 80) << (y > 59));
y = remap[y][1]; y = remap[y][1];
} }
tbl[m] = (x<<1)|(y<<9); tbl[m] = (x << 1) | (y << 9);
break; break;
case 960: case 960:
blk = (chan*10+seq)*27+slot; blk = (chan * 10 + seq) * 27 + slot;
i = (4*chan + (seq/5) + 2*blk + off[m])%10; i = (4 * chan + (seq / 5) + 2 * blk + off[m]) % 10;
k = (blk/5)%27 + (i&1)*3; k = (blk / 5) % 27 + (i & 1) * 3;
x = shuf2[m] + k%6 + 6*(chan&1); x = shuf2[m] + k % 6 + 6 * (chan & 1);
y = l_start[i] + k/6 + 45*(chan>>1); y = l_start[i] + k / 6 + 45 * (chan >> 1);
tbl[m] = (x<<1)|(y<<9); tbl[m] = (x << 1) | (y << 9);
break; break;
case 720: case 720:
switch (d->pix_fmt) { switch (d->pix_fmt) {
case AV_PIX_FMT_YUV422P: case AV_PIX_FMT_YUV422P:
x = shuf3[m] + slot/3; x = shuf3[m] + slot / 3;
y = serpent1[slot] + y = serpent1[slot] +
((((seq + off[m]) % d->difseg_size)<<1) + chan)*3; ((((seq + off[m]) % d->difseg_size) << 1) + chan) * 3;
tbl[m] = (x<<1)|(y<<8); tbl[m] = (x << 1) | (y << 8);
break; break;
case AV_PIX_FMT_YUV420P: case AV_PIX_FMT_YUV420P:
x = shuf3[m] + slot/3; x = shuf3[m] + slot / 3;
y = serpent1[slot] + y = serpent1[slot] +
((seq + off[m]) % d->difseg_size)*3; ((seq + off[m]) % d->difseg_size) * 3;
tbl[m] = (x<<1)|(y<<9); tbl[m] = (x << 1) | (y << 9);
break; break;
case AV_PIX_FMT_YUV411P: case AV_PIX_FMT_YUV411P:
i = (seq + off[m]) % d->difseg_size; i = (seq + off[m]) % d->difseg_size;
k = slot + ((m==1||m==2)?3:0); k = slot + ((m == 1 || m == 2) ? 3 : 0);
x = l_start_shuffled[m] + k/6; x = l_start_shuffled[m] + k / 6;
y = serpent2[k] + i*6; y = serpent2[k] + i * 6;
if (x>21) if (x > 21)
y = y*2 - i*6; y = y * 2 - i * 6;
tbl[m] = (x<<2)|(y<<8); tbl[m] = (x << 2) | (y << 8);
break; break;
} }
default: default:
break; break;
} }
} }
} }
@ -173,11 +180,11 @@ static const uint8_t dv100_qstep[16] = {
2, 3, 4, 5, 6, 7, 8, 16, 18, 20, 22, 24, 28, 52 2, 3, 4, 5, 6, 7, 8, 16, 18, 20, 22, 24, 28, 52
}; };
static const uint8_t dv_quant_areas[4] = { 6, 21, 43, 64 }; static const uint8_t dv_quant_areas[4] = { 6, 21, 43, 64 };
int ff_dv_init_dynamic_tables(DVVideoContext *ctx, const AVDVProfile *d) int ff_dv_init_dynamic_tables(DVVideoContext *ctx, const AVDVProfile *d)
{ {
int j,i,c,s,p; int j, i, c, s, p;
uint32_t *factor1, *factor2; uint32_t *factor1, *factor2;
const int *iweight1, *iweight2; const int *iweight1, *iweight2;
@ -189,8 +196,8 @@ int ff_dv_init_dynamic_tables(DVVideoContext *ctx, const AVDVProfile *d)
p += !(j % 3); p += !(j % 3);
if (!(DV_PROFILE_IS_1080i50(d) && c != 0 && s == 11) && if (!(DV_PROFILE_IS_1080i50(d) && c != 0 && s == 11) &&
!(DV_PROFILE_IS_720p50(d) && s > 9)) { !(DV_PROFILE_IS_720p50(d) && s > 9)) {
dv_calc_mb_coordinates(d, c, s, j, &ctx->work_chunks[i].mb_coordinates[0]); dv_calc_mb_coordinates(d, c, s, j, &ctx->work_chunks[i].mb_coordinates[0]);
ctx->work_chunks[i++].buf_offset = p; ctx->work_chunks[i++].buf_offset = p;
} }
p += 5; p += 5;
} }
@ -240,10 +247,10 @@ av_cold int ff_dvvideo_init(AVCodecContext *avctx)
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;
@ -267,21 +274,21 @@ av_cold int ff_dvvideo_init(AVCodecContext *avctx)
} }
/* NOTE: as a trick, we use the fact the no codes are unused /* NOTE: as a trick, we use the fact the no codes are unused
to accelerate the parsing of partial codes */ * to accelerate the parsing of partial codes */
init_vlc(&dv_vlc, TEX_VLC_BITS, j, init_vlc(&dv_vlc, TEX_VLC_BITS, j, new_dv_vlc_len,
new_dv_vlc_len, 1, 1, new_dv_vlc_bits, 2, 2, 0); 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];
} }
ff_dv_rl_vlc[i].len = len; ff_dv_rl_vlc[i].len = len;

73
libavcodec/dv.h
Unescape View File

@ -28,13 +28,13 @@
#define AVCODEC_DV_H #define AVCODEC_DV_H
#include "avcodec.h" #include "avcodec.h"
#include "me_cmp.h"
#include "get_bits.h"
#include "dv_profile.h" #include "dv_profile.h"
#include "get_bits.h"
#include "me_cmp.h"
typedef struct DVwork_chunk { typedef struct DVwork_chunk {
uint16_t buf_offset; uint16_t buf_offset;
uint16_t mb_coordinates[5]; uint16_t mb_coordinates[5];
} DVwork_chunk; } DVwork_chunk;
typedef struct DVVideoContext { typedef struct DVVideoContext {
@ -43,7 +43,7 @@ typedef struct DVVideoContext {
AVCodecContext *avctx; AVCodecContext *avctx;
uint8_t *buf; uint8_t *buf;
uint8_t dv_zigzag[2][64]; uint8_t dv_zigzag[2][64];
void (*get_pixels)(int16_t *block, const uint8_t *pixels, int line_size); void (*get_pixels)(int16_t *block, const uint8_t *pixels, int line_size);
void (*fdct[2])(int16_t *block); void (*fdct[2])(int16_t *block);
@ -54,26 +54,26 @@ typedef struct DVVideoContext {
} DVVideoContext; } DVVideoContext;
enum dv_section_type { enum dv_section_type {
dv_sect_header = 0x1f, dv_sect_header = 0x1f,
dv_sect_subcode = 0x3f, dv_sect_subcode = 0x3f,
dv_sect_vaux = 0x56, dv_sect_vaux = 0x56,
dv_sect_audio = 0x76, dv_sect_audio = 0x76,
dv_sect_video = 0x96, dv_sect_video = 0x96,
}; };
enum dv_pack_type { enum dv_pack_type {
dv_header525 = 0x3f, /* see dv_write_pack for important details on */ dv_header525 = 0x3f, /* see dv_write_pack for important details on */
dv_header625 = 0xbf, /* these two packs */ dv_header625 = 0xbf, /* these two packs */
dv_timecode = 0x13, dv_timecode = 0x13,
dv_audio_source = 0x50, dv_audio_source = 0x50,
dv_audio_control = 0x51, dv_audio_control = 0x51,
dv_audio_recdate = 0x52, dv_audio_recdate = 0x52,
dv_audio_rectime = 0x53, dv_audio_rectime = 0x53,
dv_video_source = 0x60, dv_video_source = 0x60,
dv_video_control = 0x61, dv_video_control = 0x61,
dv_video_recdate = 0x62, dv_video_recdate = 0x62,
dv_video_rectime = 0x63, dv_video_rectime = 0x63,
dv_unknown_pack = 0xff, dv_unknown_pack = 0xff,
}; };
#define DV_PROFILE_IS_HD(p) ((p)->video_stype & 0x10) #define DV_PROFILE_IS_HD(p) ((p)->video_stype & 0x10)
@ -81,8 +81,8 @@ enum dv_pack_type {
#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 /* minimum number of bytes to read from a DV stream in order to
determine the profile */ * determine the profile */
#define DV_PROFILE_BYTES (6*80) /* 6 DIF blocks */ #define DV_PROFILE_BYTES (6 * 80) /* 6 DIF blocks */
/** /**
* largest possible DV frame, in bytes (1080i50) * largest possible DV frame, in bytes (1080i50)
@ -103,23 +103,26 @@ int ff_dvvideo_init(AVCodecContext *avctx);
static inline int dv_work_pool_size(const AVDVProfile *d) static inline int dv_work_pool_size(const AVDVProfile *d)
{ {
int size = d->n_difchan*d->difseg_size*27; int size = d->n_difchan * d->difseg_size * 27;
if (DV_PROFILE_IS_1080i50(d)) if (DV_PROFILE_IS_1080i50(d))
size -= 3*27; size -= 3 * 27;
if (DV_PROFILE_IS_720p50(d)) if (DV_PROFILE_IS_720p50(d))
size -= 4*27; size -= 4 * 27;
return size; return size;
} }
static inline void dv_calculate_mb_xy(DVVideoContext *s, DVwork_chunk *work_chunk, int m, int *mb_x, int *mb_y) static inline void dv_calculate_mb_xy(DVVideoContext *s,
DVwork_chunk *work_chunk,
int m, int *mb_x, int *mb_y)
{ {
*mb_x = work_chunk->mb_coordinates[m] & 0xff; *mb_x = work_chunk->mb_coordinates[m] & 0xff;
*mb_y = work_chunk->mb_coordinates[m] >> 8; *mb_y = work_chunk->mb_coordinates[m] >> 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.
if (s->sys->height == 720 && !(s->buf[1]&0x0C)) { * The odd half-frame (chan == 2,3) is displaced :-( */
*mb_y -= (*mb_y>17)?18:-72; /* shifting the Y coordinate down by 72/2 macro blocks */ if (s->sys->height == 720 && !(s->buf[1] & 0x0C))
} /* shifting the Y coordinate down by 72/2 macro blocks */
*mb_y -= (*mb_y > 17) ? 18 : -72;
} }
#endif /* AVCODEC_DV_H */ #endif /* AVCODEC_DV_H */

389
libavcodec/dv_profile.c
Unescape View File

@ -16,13 +16,14 @@
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/ */
#include <stdint.h>
#include "config.h" #include "config.h"
#include <stdint.h>
#include "libavutil/common.h" #include "libavutil/common.h"
#include "libavutil/log.h" #include "libavutil/log.h"
#include "libavutil/pixdesc.h" #include "libavutil/pixdesc.h"
#include "avcodec.h" #include "avcodec.h"
#include "dv_profile.h" #include "dv_profile.h"
#include "dv_profile_internal.h" #include "dv_profile_internal.h"
@ -30,33 +31,33 @@
#if CONFIG_DVPROFILE #if CONFIG_DVPROFILE
static const uint8_t dv_audio_shuffle525[10][9] = { static const uint8_t dv_audio_shuffle525[10][9] = {
{ 0, 30, 60, 20, 50, 80, 10, 40, 70 }, /* 1st channel */ { 0, 30, 60, 20, 50, 80, 10, 40, 70 }, /* 1st channel */
{ 6, 36, 66, 26, 56, 86, 16, 46, 76 }, { 6, 36, 66, 26, 56, 86, 16, 46, 76 },
{ 12, 42, 72, 2, 32, 62, 22, 52, 82 }, { 12, 42, 72, 2, 32, 62, 22, 52, 82 },
{ 18, 48, 78, 8, 38, 68, 28, 58, 88 }, { 18, 48, 78, 8, 38, 68, 28, 58, 88 },
{ 24, 54, 84, 14, 44, 74, 4, 34, 64 }, { 24, 54, 84, 14, 44, 74, 4, 34, 64 },
{ 1, 31, 61, 21, 51, 81, 11, 41, 71 }, /* 2nd channel */ { 1, 31, 61, 21, 51, 81, 11, 41, 71 }, /* 2nd channel */
{ 7, 37, 67, 27, 57, 87, 17, 47, 77 }, { 7, 37, 67, 27, 57, 87, 17, 47, 77 },
{ 13, 43, 73, 3, 33, 63, 23, 53, 83 }, { 13, 43, 73, 3, 33, 63, 23, 53, 83 },
{ 19, 49, 79, 9, 39, 69, 29, 59, 89 }, { 19, 49, 79, 9, 39, 69, 29, 59, 89 },
{ 25, 55, 85, 15, 45, 75, 5, 35, 65 }, { 25, 55, 85, 15, 45, 75, 5, 35, 65 },
}; };
static const uint8_t dv_audio_shuffle625[12][9] = { static const uint8_t dv_audio_shuffle625[12][9] = {
{ 0, 36, 72, 26, 62, 98, 16, 52, 88}, /* 1st channel */ { 0, 36, 72, 26, 62, 98, 16, 52, 88 }, /* 1st channel */
{ 6, 42, 78, 32, 68, 104, 22, 58, 94}, { 6, 42, 78, 32, 68, 104, 22, 58, 94 },
{ 12, 48, 84, 2, 38, 74, 28, 64, 100}, { 12, 48, 84, 2, 38, 74, 28, 64, 100 },
{ 18, 54, 90, 8, 44, 80, 34, 70, 106}, { 18, 54, 90, 8, 44, 80, 34, 70, 106 },
{ 24, 60, 96, 14, 50, 86, 4, 40, 76}, { 24, 60, 96, 14, 50, 86, 4, 40, 76 },
{ 30, 66, 102, 20, 56, 92, 10, 46, 82}, { 30, 66, 102, 20, 56, 92, 10, 46, 82 },
{ 1, 37, 73, 27, 63, 99, 17, 53, 89}, /* 2nd channel */ { 1, 37, 73, 27, 63, 99, 17, 53, 89 }, /* 2nd channel */
{ 7, 43, 79, 33, 69, 105, 23, 59, 95}, { 7, 43, 79, 33, 69, 105, 23, 59, 95 },
{ 13, 49, 85, 3, 39, 75, 29, 65, 101}, { 13, 49, 85, 3, 39, 75, 29, 65, 101 },
{ 19, 55, 91, 9, 45, 81, 35, 71, 107}, { 19, 55, 91, 9, 45, 81, 35, 71, 107 },
{ 25, 61, 97, 15, 51, 87, 5, 41, 77}, { 25, 61, 97, 15, 51, 87, 5, 41, 77 },
{ 31, 67, 103, 21, 57, 93, 11, 47, 83}, { 31, 67, 103, 21, 57, 93, 11, 47, 83 },
}; };
/* macroblock bit budgets */ /* macroblock bit budgets */
@ -69,186 +70,176 @@ static const uint8_t block_sizes_dv100[8] = {
}; };
static const AVDVProfile dv_profiles[] = { static const AVDVProfile dv_profiles[] = {
{ .dsf = 0, { .dsf = 0,
.video_stype = 0x0, .video_stype = 0x0,
.frame_size = 120000, /* IEC 61834, SMPTE-314M - 525/60 (NTSC) */ .frame_size = 120000, /* IEC 61834, SMPTE-314M - 525/60 (NTSC) */
.difseg_size = 10, .difseg_size = 10,
.n_difchan = 1, .n_difchan = 1,
.time_base = { 1001, 30000 }, .time_base = { 1001, 30000 },
.ltc_divisor = 30, .ltc_divisor = 30,
.height = 480, .height = 480,
.width = 720, .width = 720,
.sar = {{8, 9}, {32, 27}}, .sar = { { 8, 9 }, { 32, 27 } },
.pix_fmt = AV_PIX_FMT_YUV411P, .pix_fmt = AV_PIX_FMT_YUV411P,
.bpm = 6, .bpm = 6,
.block_sizes = block_sizes_dv2550, .block_sizes = block_sizes_dv2550,
.audio_stride = 90, .audio_stride = 90,
.audio_min_samples = { 1580, 1452, 1053 }, /* for 48, 44.1 and 32kHz */ .audio_min_samples = { 1580, 1452, 1053 }, /* for 48, 44.1 and 32kHz */
.audio_samples_dist = { 1600, 1602, 1602, 1602, 1602 }, /* per SMPTE-314M */ .audio_samples_dist = { 1600, 1602, 1602, 1602, 1602 }, /* per SMPTE-314M */
.audio_shuffle = dv_audio_shuffle525, .audio_shuffle = dv_audio_shuffle525, },
}, { .dsf = 1,
{ .dsf = 1, .video_stype = 0x0,
.video_stype = 0x0, .frame_size = 144000, /* IEC 61834 - 625/50 (PAL) */
.frame_size = 144000, /* IEC 61834 - 625/50 (PAL) */ .difseg_size = 12,
.difseg_size = 12, .n_difchan = 1,
.n_difchan = 1, .time_base = { 1, 25 },
.time_base = { 1, 25 }, .ltc_divisor = 25,
.ltc_divisor = 25, .height = 576,
.height = 576, .width = 720,
.width = 720, .sar = { { 16, 15 }, { 64, 45 } },
.sar = {{16, 15}, {64, 45}}, .pix_fmt = AV_PIX_FMT_YUV420P,
.pix_fmt = AV_PIX_FMT_YUV420P, .bpm = 6,
.bpm = 6, .block_sizes = block_sizes_dv2550,
.block_sizes = block_sizes_dv2550, .audio_stride = 108,
.audio_stride = 108,
.audio_min_samples = { 1896, 1742, 1264 }, /* for 48, 44.1 and 32kHz */ .audio_min_samples = { 1896, 1742, 1264 }, /* for 48, 44.1 and 32kHz */
.audio_samples_dist = { 1920, 1920, 1920, 1920, 1920 }, .audio_samples_dist = { 1920, 1920, 1920, 1920, 1920 },
.audio_shuffle = dv_audio_shuffle625, .audio_shuffle = dv_audio_shuffle625, },
}, { .dsf = 1,
{ .dsf = 1, .video_stype = 0x0,
.video_stype = 0x0, .frame_size = 144000, /* SMPTE-314M - 625/50 (PAL) */
.frame_size = 144000, /* SMPTE-314M - 625/50 (PAL) */ .difseg_size = 12,
.difseg_size = 12, .n_difchan = 1,
.n_difchan = 1, .time_base = { 1, 25 },
.time_base = { 1, 25 }, .ltc_divisor = 25,
.ltc_divisor = 25, .height = 576,
.height = 576, .width = 720,
.width = 720, .sar = { { 16, 15 }, { 64, 45 } },
.sar = {{16, 15}, {64, 45}}, .pix_fmt = AV_PIX_FMT_YUV411P,
.pix_fmt = AV_PIX_FMT_YUV411P, .bpm = 6,
.bpm = 6, .block_sizes = block_sizes_dv2550,
.block_sizes = block_sizes_dv2550, .audio_stride = 108,
.audio_stride = 108,
.audio_min_samples = { 1896, 1742, 1264 }, /* for 48, 44.1 and 32kHz */ .audio_min_samples = { 1896, 1742, 1264 }, /* for 48, 44.1 and 32kHz */
.audio_samples_dist = { 1920, 1920, 1920, 1920, 1920 }, .audio_samples_dist = { 1920, 1920, 1920, 1920, 1920 },
.audio_shuffle = dv_audio_shuffle625, .audio_shuffle = dv_audio_shuffle625, },
}, { .dsf = 0,
{ .dsf = 0, .video_stype = 0x4,
.video_stype = 0x4, .frame_size = 240000, /* SMPTE-314M - 525/60 (NTSC) 50 Mbps */
.frame_size = 240000, /* SMPTE-314M - 525/60 (NTSC) 50 Mbps */ .difseg_size = 10, /* also known as "DVCPRO50" */
.difseg_size = 10, /* also known as "DVCPRO50" */ .n_difchan = 2,
.n_difchan = 2, .time_base = { 1001, 30000 },
.time_base = { 1001, 30000 }, .ltc_divisor = 30,
.ltc_divisor = 30, .height = 480,
.height = 480, .width = 720,
.width = 720, .sar = { { 8, 9 }, { 32, 27 } },
.sar = {{8, 9}, {32, 27}}, .pix_fmt = AV_PIX_FMT_YUV422P,
.pix_fmt = AV_PIX_FMT_YUV422P, .bpm = 6,
.bpm = 6, .block_sizes = block_sizes_dv2550,
.block_sizes = block_sizes_dv2550, .audio_stride = 90,
.audio_stride = 90,
.audio_min_samples = { 1580, 1452, 1053 }, /* for 48, 44.1 and 32kHz */ .audio_min_samples = { 1580, 1452, 1053 }, /* for 48, 44.1 and 32kHz */
.audio_samples_dist = { 1600, 1602, 1602, 1602, 1602 }, /* per SMPTE-314M */ .audio_samples_dist = { 1600, 1602, 1602, 1602, 1602 }, /* per SMPTE-314M */
.audio_shuffle = dv_audio_shuffle525, .audio_shuffle = dv_audio_shuffle525, },
}, { .dsf = 1,
{ .dsf = 1, .video_stype = 0x4,
.video_stype = 0x4, .frame_size = 288000, /* SMPTE-314M - 625/50 (PAL) 50 Mbps */
.frame_size = 288000, /* SMPTE-314M - 625/50 (PAL) 50 Mbps */ .difseg_size = 12, /* also known as "DVCPRO50" */
.difseg_size = 12, /* also known as "DVCPRO50" */ .n_difchan = 2,
.n_difchan = 2, .time_base = { 1, 25 },
.time_base = { 1, 25 }, .ltc_divisor = 25,
.ltc_divisor = 25, .height = 576,
.height = 576, .width = 720,
.width = 720, .sar = { { 16, 15 }, { 64, 45 } },
.sar = {{16, 15}, {64, 45}}, .pix_fmt = AV_PIX_FMT_YUV422P,
.pix_fmt = AV_PIX_FMT_YUV422P, .bpm = 6,
.bpm = 6, .block_sizes = block_sizes_dv2550,
.block_sizes = block_sizes_dv2550, .audio_stride = 108,
.audio_stride = 108,
.audio_min_samples = { 1896, 1742, 1264 }, /* for 48, 44.1 and 32kHz */ .audio_min_samples = { 1896, 1742, 1264 }, /* for 48, 44.1 and 32kHz */
.audio_samples_dist = { 1920, 1920, 1920, 1920, 1920 }, .audio_samples_dist = { 1920, 1920, 1920, 1920, 1920 },
.audio_shuffle = dv_audio_shuffle625, .audio_shuffle = dv_audio_shuffle625, },
}, { .dsf = 0,
{ .dsf = 0, .video_stype = 0x14,
.video_stype = 0x14, .frame_size = 480000, /* SMPTE-370M - 1080i60 100 Mbps */
.frame_size = 480000, /* SMPTE-370M - 1080i60 100 Mbps */ .difseg_size = 10, /* also known as "DVCPRO HD" */
.difseg_size = 10, /* also known as "DVCPRO HD" */ .n_difchan = 4,
.n_difchan = 4, .time_base = { 1001, 30000 },
.time_base = { 1001, 30000 }, .ltc_divisor = 30,
.ltc_divisor = 30, .height = 1080,
.height = 1080, .width = 1280,
.width = 1280, .sar = { { 1, 1 }, { 3, 2 } },
.sar = {{1, 1}, {3, 2}}, .pix_fmt = AV_PIX_FMT_YUV422P,
.pix_fmt = AV_PIX_FMT_YUV422P, .bpm = 8,
.bpm = 8, .block_sizes = block_sizes_dv100,
.block_sizes = block_sizes_dv100, .audio_stride = 90,
.audio_stride = 90,
.audio_min_samples = { 1580, 1452, 1053 }, /* for 48, 44.1 and 32kHz */ .audio_min_samples = { 1580, 1452, 1053 }, /* for 48, 44.1 and 32kHz */
.audio_samples_dist = { 1600, 1602, 1602, 1602, 1602 }, /* per SMPTE-314M */ .audio_samples_dist = { 1600, 1602, 1602, 1602, 1602 }, /* per SMPTE-314M */
.audio_shuffle = dv_audio_shuffle525, .audio_shuffle = dv_audio_shuffle525, },
}, { .dsf = 1,
{ .dsf = 1, .video_stype = 0x14,
.video_stype = 0x14, .frame_size = 576000, /* SMPTE-370M - 1080i50 100 Mbps */
.frame_size = 576000, /* SMPTE-370M - 1080i50 100 Mbps */ .difseg_size = 12, /* also known as "DVCPRO HD" */
.difseg_size = 12, /* also known as "DVCPRO HD" */ .n_difchan = 4,
.n_difchan = 4, .time_base = { 1, 25 },
.time_base = { 1, 25 }, .ltc_divisor = 25,
.ltc_divisor = 25, .height = 1080,
.height = 1080, .width = 1440,
.width = 1440, .sar = { { 1, 1 }, { 4, 3 } },
.sar = {{1, 1}, {4, 3}}, .pix_fmt = AV_PIX_FMT_YUV422P,
.pix_fmt = AV_PIX_FMT_YUV422P, .bpm = 8,
.bpm = 8, .block_sizes = block_sizes_dv100,
.block_sizes = block_sizes_dv100, .audio_stride = 108,
.audio_stride = 108,
.audio_min_samples = { 1896, 1742, 1264 }, /* for 48, 44.1 and 32kHz */ .audio_min_samples = { 1896, 1742, 1264 }, /* for 48, 44.1 and 32kHz */
.audio_samples_dist = { 1920, 1920, 1920, 1920, 1920 }, .audio_samples_dist = { 1920, 1920, 1920, 1920, 1920 },
.audio_shuffle = dv_audio_shuffle625, .audio_shuffle = dv_audio_shuffle625, },
}, { .dsf = 0,
{ .dsf = 0, .video_stype = 0x18,
.video_stype = 0x18, .frame_size = 240000, /* SMPTE-370M - 720p60 100 Mbps */
.frame_size = 240000, /* SMPTE-370M - 720p60 100 Mbps */ .difseg_size = 10, /* also known as "DVCPRO HD" */
.difseg_size = 10, /* also known as "DVCPRO HD" */ .n_difchan = 2,
.n_difchan = 2, .time_base = { 1001, 60000 },
.time_base = { 1001, 60000 }, .ltc_divisor = 60,
.ltc_divisor = 60, .height = 720,
.height = 720, .width = 960,
.width = 960, .sar = { { 1, 1 }, { 4, 3 } },
.sar = {{1, 1}, {4, 3}}, .pix_fmt = AV_PIX_FMT_YUV422P,
.pix_fmt = AV_PIX_FMT_YUV422P, .bpm = 8,
.bpm = 8, .block_sizes = block_sizes_dv100,
.block_sizes = block_sizes_dv100, .audio_stride = 90,
.audio_stride = 90,
.audio_min_samples = { 1580, 1452, 1053 }, /* for 48, 44.1 and 32kHz */ .audio_min_samples = { 1580, 1452, 1053 }, /* for 48, 44.1 and 32kHz */
.audio_samples_dist = { 1600, 1602, 1602, 1602, 1602 }, /* per SMPTE-314M */ .audio_samples_dist = { 1600, 1602, 1602, 1602, 1602 }, /* per SMPTE-314M */
.audio_shuffle = dv_audio_shuffle525, .audio_shuffle = dv_audio_shuffle525, },
}, { .dsf = 1,
{ .dsf = 1, .video_stype = 0x18,
.video_stype = 0x18, .frame_size = 288000, /* SMPTE-370M - 720p50 100 Mbps */
.frame_size = 288000, /* SMPTE-370M - 720p50 100 Mbps */ .difseg_size = 12, /* also known as "DVCPRO HD" */
.difseg_size = 12, /* also known as "DVCPRO HD" */ .n_difchan = 2,
.n_difchan = 2, .time_base = { 1, 50 },
.time_base = { 1, 50 }, .ltc_divisor = 50,
.ltc_divisor = 50, .height = 720,
.height = 720, .width = 960,
.width = 960, .sar = { { 1, 1 }, { 4, 3 } },
.sar = {{1, 1}, {4, 3}}, .pix_fmt = AV_PIX_FMT_YUV422P,
.pix_fmt = AV_PIX_FMT_YUV422P, .bpm = 8,
.bpm = 8, .block_sizes = block_sizes_dv100,
.block_sizes = block_sizes_dv100, .audio_stride = 90,
.audio_stride = 90,
.audio_min_samples = { 1896, 1742, 1264 }, /* for 48, 44.1 and 32kHz */ .audio_min_samples = { 1896, 1742, 1264 }, /* for 48, 44.1 and 32kHz */
.audio_samples_dist = { 1920, 1920, 1920, 1920, 1920 }, .audio_samples_dist = { 1920, 1920, 1920, 1920, 1920 },
.audio_shuffle = dv_audio_shuffle625, .audio_shuffle = dv_audio_shuffle625, },
}, { .dsf = 1,
{ .dsf = 1, .video_stype = 0x1,
.video_stype = 0x1, .frame_size = 144000, /* IEC 61883-5 - 625/50 (PAL) */
.frame_size = 144000, /* IEC 61883-5 - 625/50 (PAL) */ .difseg_size = 12,
.difseg_size = 12, .n_difchan = 1,
.n_difchan = 1, .time_base = { 1, 25 },
.time_base = { 1, 25 }, .ltc_divisor = 25,
.ltc_divisor = 25, .height = 576,
.height = 576, .width = 720,
.width = 720, .sar = { { 16, 15 }, { 64, 45 } },
.sar = {{16, 15}, {64, 45}}, .pix_fmt = AV_PIX_FMT_YUV420P,
.pix_fmt = AV_PIX_FMT_YUV420P, .bpm = 6,
.bpm = 6, .block_sizes = block_sizes_dv2550,
.block_sizes = block_sizes_dv2550, .audio_stride = 108,
.audio_stride = 108,
.audio_min_samples = { 1896, 1742, 1264 }, /* for 48, 44.1 and 32kHz */ .audio_min_samples = { 1896, 1742, 1264 }, /* for 48, 44.1 and 32kHz */
.audio_samples_dist = { 1920, 1920, 1920, 1920, 1920 }, .audio_samples_dist = { 1920, 1920, 1920, 1920, 1920 },
.audio_shuffle = dv_audio_shuffle625, .audio_shuffle = dv_audio_shuffle625, }
}
}; };
void ff_dv_print_profiles(void *logctx, int loglevel) void ff_dv_print_profiles(void *logctx, int loglevel)
@ -256,8 +247,9 @@ void ff_dv_print_profiles(void *logctx, int loglevel)
int i; int i;
for (i = 0; i < FF_ARRAY_ELEMS(dv_profiles); i++) { for (i = 0; i < FF_ARRAY_ELEMS(dv_profiles); i++) {
const AVDVProfile *p = &dv_profiles[i]; const AVDVProfile *p = &dv_profiles[i];
av_log(logctx, loglevel, "Frame size: %dx%d; pixel format: %s, " av_log(logctx, loglevel,
"framerate: %d/%d\n", p->width, p->height, av_get_pix_fmt_name(p->pix_fmt), "Frame size: %dx%d; pixel format: %s, framerate: %d/%d\n",
p->width, p->height, av_get_pix_fmt_name(p->pix_fmt),
p->time_base.den, p->time_base.num); p->time_base.den, p->time_base.num);
} }
} }
@ -265,7 +257,7 @@ void ff_dv_print_profiles(void *logctx, int loglevel)
#endif /* CONFIG_DVPROFILE */ #endif /* CONFIG_DVPROFILE */
const AVDVProfile *av_dv_frame_profile(const AVDVProfile *sys, const AVDVProfile *av_dv_frame_profile(const AVDVProfile *sys,
const uint8_t* frame, unsigned buf_size) const uint8_t *frame, unsigned buf_size)
{ {
#if CONFIG_DVPROFILE #if CONFIG_DVPROFILE
int i, dsf, stype; int i, dsf, stype;
@ -273,13 +265,12 @@ const AVDVProfile *av_dv_frame_profile(const AVDVProfile *sys,
if (buf_size < 80 * 5 + 48 + 4) if (buf_size < 80 * 5 + 48 + 4)
return NULL; return NULL;
dsf = (frame[3] & 0x80) >> 7; dsf = (frame[3] & 0x80) >> 7;
stype = frame[80 * 5 + 48 + 3] & 0x1f; stype = frame[80 * 5 + 48 + 3] & 0x1f;
/* 576i50 25Mbps 4:1:1 is a special case */ /* 576i50 25Mbps 4:1:1 is a special case */
if (dsf == 1 && stype == 0 && frame[4] & 0x07 /* the APT field */) { if (dsf == 1 && stype == 0 && frame[4] & 0x07 /* the APT field */)
return &dv_profiles[2]; return &dv_profiles[2];
}
for (i = 0; i < FF_ARRAY_ELEMS(dv_profiles); i++) for (i = 0; i < FF_ARRAY_ELEMS(dv_profiles); i++)
if (dsf == dv_profiles[i].dsf && stype == dv_profiles[i].video_stype) if (dsf == dv_profiles[i].dsf && stype == dv_profiles[i].video_stype)
@ -299,11 +290,11 @@ const AVDVProfile *av_dv_codec_profile(int width, int height,
#if CONFIG_DVPROFILE #if CONFIG_DVPROFILE
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 (height == dv_profiles[i].height && if (height == dv_profiles[i].height &&
pix_fmt == dv_profiles[i].pix_fmt && pix_fmt == dv_profiles[i].pix_fmt &&
width == dv_profiles[i].width) width == dv_profiles[i].width)
return &dv_profiles[i]; return &dv_profiles[i];
#endif #endif
return NULL; return NULL;

70
libavcodec/dv_tablegen.h
Unescape View File

@ -28,17 +28,17 @@
#include "dvdata.h" #include "dvdata.h"
#if CONFIG_SMALL #if CONFIG_SMALL
#define DV_VLC_MAP_RUN_SIZE 15 #define DV_VLC_MAP_RUN_SIZE 15
#define DV_VLC_MAP_LEV_SIZE 23 #define DV_VLC_MAP_LEV_SIZE 23
#else #else
#define DV_VLC_MAP_RUN_SIZE 64 #define DV_VLC_MAP_RUN_SIZE 64
#define DV_VLC_MAP_LEV_SIZE 512 //FIXME sign was removed so this should be /2 but needs check #define DV_VLC_MAP_LEV_SIZE 512 // FIXME sign was removed so this should be /2 but needs check
#endif #endif
/* VLC encoding lookup table */ /* VLC encoding lookup table */
typedef struct dv_vlc_pair { typedef struct dv_vlc_pair {
uint32_t vlc; uint32_t vlc;
uint32_t size; uint32_t size;
} dv_vlc_pair; } dv_vlc_pair;
#if CONFIG_HARDCODED_TABLES #if CONFIG_HARDCODED_TABLES
@ -51,44 +51,44 @@ static void dv_vlc_map_tableinit(void)
{ {
int i, j; int i, j;
for (i = 0; i < NB_DV_VLC - 1; i++) { for (i = 0; i < NB_DV_VLC - 1; i++) {
if (ff_dv_vlc_run[i] >= DV_VLC_MAP_RUN_SIZE) if (ff_dv_vlc_run[i] >= DV_VLC_MAP_RUN_SIZE)
continue; continue;
#if CONFIG_SMALL #if CONFIG_SMALL
if (ff_dv_vlc_level[i] >= DV_VLC_MAP_LEV_SIZE) if (ff_dv_vlc_level[i] >= DV_VLC_MAP_LEV_SIZE)
continue; continue;
#endif #endif
if (dv_vlc_map[ff_dv_vlc_run[i]][ff_dv_vlc_level[i]].size != 0) if (dv_vlc_map[ff_dv_vlc_run[i]][ff_dv_vlc_level[i]].size != 0)
continue; continue;
dv_vlc_map[ff_dv_vlc_run[i]][ff_dv_vlc_level[i]].vlc = dv_vlc_map[ff_dv_vlc_run[i]][ff_dv_vlc_level[i]].vlc =
ff_dv_vlc_bits[i] << (!!ff_dv_vlc_level[i]); ff_dv_vlc_bits[i] << (!!ff_dv_vlc_level[i]);
dv_vlc_map[ff_dv_vlc_run[i]][ff_dv_vlc_level[i]].size = dv_vlc_map[ff_dv_vlc_run[i]][ff_dv_vlc_level[i]].size =
ff_dv_vlc_len[i] + (!!ff_dv_vlc_level[i]); ff_dv_vlc_len[i] + (!!ff_dv_vlc_level[i]);
} }
for (i = 0; i < DV_VLC_MAP_RUN_SIZE; i++) { for (i = 0; i < DV_VLC_MAP_RUN_SIZE; i++) {
#if CONFIG_SMALL #if CONFIG_SMALL
for (j = 1; j < DV_VLC_MAP_LEV_SIZE; j++) { for (j = 1; j < DV_VLC_MAP_LEV_SIZE; j++) {
if (dv_vlc_map[i][j].size == 0) { if (dv_vlc_map[i][j].size == 0) {
dv_vlc_map[i][j].vlc = dv_vlc_map[0][j].vlc | dv_vlc_map[i][j].vlc = dv_vlc_map[0][j].vlc |
(dv_vlc_map[i-1][0].vlc << (dv_vlc_map[0][j].size)); (dv_vlc_map[i - 1][0].vlc <<
dv_vlc_map[i][j].size = dv_vlc_map[i-1][0].size + dv_vlc_map[0][j].size);
dv_vlc_map[0][j].size; dv_vlc_map[i][j].size = dv_vlc_map[i - 1][0].size +
} dv_vlc_map[0][j].size;
} }
}
#else #else
for (j = 1; j < DV_VLC_MAP_LEV_SIZE/2; j++) { for (j = 1; j < DV_VLC_MAP_LEV_SIZE / 2; j++) {
if (dv_vlc_map[i][j].size == 0) { if (dv_vlc_map[i][j].size == 0) {
dv_vlc_map[i][j].vlc = dv_vlc_map[0][j].vlc | dv_vlc_map[i][j].vlc = dv_vlc_map[0][j].vlc |
(dv_vlc_map[i-1][0].vlc << (dv_vlc_map[0][j].size)); (dv_vlc_map[i - 1][0].vlc <<
dv_vlc_map[i][j].size = dv_vlc_map[i-1][0].size + dv_vlc_map[0][j].size);
dv_vlc_map[0][j].size; dv_vlc_map[i][j].size = dv_vlc_map[i - 1][0].size +
} dv_vlc_map[0][j].size;
dv_vlc_map[i][((uint16_t)(-j))&0x1ff].vlc = }
dv_vlc_map[i][j].vlc | 1; dv_vlc_map[i][((uint16_t) (-j)) & 0x1ff].vlc = dv_vlc_map[i][j].vlc | 1;
dv_vlc_map[i][((uint16_t)(-j))&0x1ff].size = dv_vlc_map[i][((uint16_t) (-j)) & 0x1ff].size = dv_vlc_map[i][j].size;
dv_vlc_map[i][j].size; }
}
#endif #endif
} }
} }

494
libavcodec/dvdata.c
Unescape View File

@ -43,51 +43,51 @@ const uint8_t ff_dv_zigzag248_direct[64] = {
/* unquant tables (not used directly) */ /* unquant tables (not used directly) */
const uint8_t ff_dv_quant_shifts[22][4] = { const uint8_t ff_dv_quant_shifts[22][4] = {
{ 3,3,4,4 }, { 3, 3, 4, 4 },
{ 3,3,4,4 }, { 3, 3, 4, 4 },
{ 2,3,3,4 }, { 2, 3, 3, 4 },
{ 2,3,3,4 }, { 2, 3, 3, 4 },
{ 2,2,3,3 }, { 2, 2, 3, 3 },
{ 2,2,3,3 }, { 2, 2, 3, 3 },
{ 1,2,2,3 }, { 1, 2, 2, 3 },
{ 1,2,2,3 }, { 1, 2, 2, 3 },
{ 1,1,2,2 }, { 1, 1, 2, 2 },
{ 1,1,2,2 }, { 1, 1, 2, 2 },
{ 0,1,1,2 }, { 0, 1, 1, 2 },
{ 0,1,1,2 }, { 0, 1, 1, 2 },
{ 0,0,1,1 }, { 0, 0, 1, 1 },
{ 0,0,1,1 }, { 0, 0, 1, 1 },
{ 0,0,0,1 }, { 0, 0, 0, 1 },
{ 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 },
}; };
const uint8_t ff_dv_quant_offset[4] = { 6, 3, 0, 1 }; const uint8_t ff_dv_quant_offset[4] = { 6, 3, 0, 1 };
const int ff_dv_iweight_88[64] = { const int ff_dv_iweight_88[64] = {
32768, 16710, 16710, 17735, 17015, 17735, 18197, 18079, 32768, 16710, 16710, 17735, 17015, 17735, 18197, 18079,
18079, 18197, 18725, 18559, 19196, 18559, 18725, 19284, 18079, 18197, 18725, 18559, 19196, 18559, 18725, 19284,
19108, 19692, 19692, 19108, 19284, 21400, 19645, 20262, 19108, 19692, 19692, 19108, 19284, 21400, 19645, 20262,
20214, 20262, 19645, 21400, 22733, 21845, 20867, 20815, 20214, 20262, 19645, 21400, 22733, 21845, 20867, 20815,
20815, 20867, 21845, 22733, 23173, 23173, 21400, 21400, 20815, 20867, 21845, 22733, 23173, 23173, 21400, 21400,
21400, 23173, 23173, 24600, 23764, 22017, 22017, 23764, 21400, 23173, 23173, 24600, 23764, 22017, 22017, 23764,
24600, 25267, 24457, 22672, 24457, 25267, 25971, 25191, 24600, 25267, 24457, 22672, 24457, 25267, 25971, 25191,
25191, 25971, 26715, 27962, 26715, 29642, 29642, 31536, 25191, 25971, 26715, 27962, 26715, 29642, 29642, 31536,
}; };
const int ff_dv_iweight_248[64] = { const int ff_dv_iweight_248[64] = {
32768, 17735, 16710, 18079, 18725, 21400, 17735, 19196, 32768, 17735, 16710, 18079, 18725, 21400, 17735, 19196,
19108, 21845, 16384, 17735, 18725, 21400, 16710, 18079, 19108, 21845, 16384, 17735, 18725, 21400, 16710, 18079,
20262, 23173, 18197, 19692, 18725, 20262, 20815, 23764, 20262, 23173, 18197, 19692, 18725, 20262, 20815, 23764,
17735, 19196, 19108, 21845, 20262, 23173, 18197, 19692, 17735, 19196, 19108, 21845, 20262, 23173, 18197, 19692,
21400, 24457, 19284, 20867, 21400, 23173, 22017, 25191, 21400, 24457, 19284, 20867, 21400, 23173, 22017, 25191,
18725, 20262, 20815, 23764, 21400, 24457, 19284, 20867, 18725, 20262, 20815, 23764, 21400, 24457, 19284, 20867,
24457, 27962, 22733, 24600, 25971, 29642, 21400, 23173, 24457, 27962, 22733, 24600, 25971, 29642, 21400, 23173,
22017, 25191, 24457, 27962, 22733, 24600, 25971, 29642, 22017, 25191, 24457, 27962, 22733, 24600, 25971, 29642,
}; };
/** /**
@ -140,221 +140,221 @@ const int ff_dv_iweight_720_c[64] = {
* when building misc. tables. E.g. (1, 0) can be either 0x7cf or 0x1f82. * when building misc. tables. E.g. (1, 0) can be either 0x7cf or 0x1f82.
*/ */
const uint16_t ff_dv_vlc_bits[NB_DV_VLC] = { const uint16_t ff_dv_vlc_bits[NB_DV_VLC] = {
0x0000, 0x0002, 0x0007, 0x0008, 0x0009, 0x0014, 0x0015, 0x0016, 0x0000, 0x0002, 0x0007, 0x0008, 0x0009, 0x0014, 0x0015, 0x0016,
0x0017, 0x0030, 0x0031, 0x0032, 0x0033, 0x0068, 0x0069, 0x006a, 0x0017, 0x0030, 0x0031, 0x0032, 0x0033, 0x0068, 0x0069, 0x006a,
0x006b, 0x006c, 0x006d, 0x006e, 0x006f, 0x00e0, 0x00e1, 0x00e2, 0x006b, 0x006c, 0x006d, 0x006e, 0x006f, 0x00e0, 0x00e1, 0x00e2,
0x00e3, 0x00e4, 0x00e5, 0x00e6, 0x00e7, 0x00e8, 0x00e9, 0x00ea, 0x00e3, 0x00e4, 0x00e5, 0x00e6, 0x00e7, 0x00e8, 0x00e9, 0x00ea,
0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef, 0x01e0, 0x01e1, 0x01e2, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef, 0x01e0, 0x01e1, 0x01e2,
0x01e3, 0x01e4, 0x01e5, 0x01e6, 0x01e7, 0x01e8, 0x01e9, 0x01ea, 0x01e3, 0x01e4, 0x01e5, 0x01e6, 0x01e7, 0x01e8, 0x01e9, 0x01ea,
0x01eb, 0x01ec, 0x01ed, 0x01ee, 0x01ef, 0x03e0, 0x03e1, 0x03e2, 0x01eb, 0x01ec, 0x01ed, 0x01ee, 0x01ef, 0x03e0, 0x03e1, 0x03e2,
0x03e3, 0x03e4, 0x03e5, 0x03e6, 0x07ce, 0x07cf, 0x07d0, 0x07d1, 0x03e3, 0x03e4, 0x03e5, 0x03e6, 0x07ce, 0x07cf, 0x07d0, 0x07d1,
0x07d2, 0x07d3, 0x07d4, 0x07d5, 0x0fac, 0x0fad, 0x0fae, 0x0faf, 0x07d2, 0x07d3, 0x07d4, 0x07d5, 0x0fac, 0x0fad, 0x0fae, 0x0faf,
0x0fb0, 0x0fb1, 0x0fb2, 0x0fb3, 0x0fb4, 0x0fb5, 0x0fb6, 0x0fb7, 0x0fb0, 0x0fb1, 0x0fb2, 0x0fb3, 0x0fb4, 0x0fb5, 0x0fb6, 0x0fb7,
0x0fb8, 0x0fb9, 0x0fba, 0x0fbb, 0x0fbc, 0x0fbd, 0x0fbe, 0x0fbf, 0x0fb8, 0x0fb9, 0x0fba, 0x0fbb, 0x0fbc, 0x0fbd, 0x0fbe, 0x0fbf,
0x1f80, 0x1f81, 0x1f82, 0x1f83, 0x1f84, 0x1f85, 0x1f86, 0x1f87, 0x1f80, 0x1f81, 0x1f82, 0x1f83, 0x1f84, 0x1f85, 0x1f86, 0x1f87,
0x1f88, 0x1f89, 0x1f8a, 0x1f8b, 0x1f8c, 0x1f8d, 0x1f8e, 0x1f8f, 0x1f88, 0x1f89, 0x1f8a, 0x1f8b, 0x1f8c, 0x1f8d, 0x1f8e, 0x1f8f,
0x1f90, 0x1f91, 0x1f92, 0x1f93, 0x1f94, 0x1f95, 0x1f96, 0x1f97, 0x1f90, 0x1f91, 0x1f92, 0x1f93, 0x1f94, 0x1f95, 0x1f96, 0x1f97,
0x1f98, 0x1f99, 0x1f9a, 0x1f9b, 0x1f9c, 0x1f9d, 0x1f9e, 0x1f9f, 0x1f98, 0x1f99, 0x1f9a, 0x1f9b, 0x1f9c, 0x1f9d, 0x1f9e, 0x1f9f,
0x1fa0, 0x1fa1, 0x1fa2, 0x1fa3, 0x1fa4, 0x1fa5, 0x1fa6, 0x1fa7, 0x1fa0, 0x1fa1, 0x1fa2, 0x1fa3, 0x1fa4, 0x1fa5, 0x1fa6, 0x1fa7,
0x1fa8, 0x1fa9, 0x1faa, 0x1fab, 0x1fac, 0x1fad, 0x1fae, 0x1faf, 0x1fa8, 0x1fa9, 0x1faa, 0x1fab, 0x1fac, 0x1fad, 0x1fae, 0x1faf,
0x1fb0, 0x1fb1, 0x1fb2, 0x1fb3, 0x1fb4, 0x1fb5, 0x1fb6, 0x1fb7, 0x1fb0, 0x1fb1, 0x1fb2, 0x1fb3, 0x1fb4, 0x1fb5, 0x1fb6, 0x1fb7,
0x1fb8, 0x1fb9, 0x1fba, 0x1fbb, 0x1fbc, 0x1fbd, 0x1fbe, 0x1fbf, 0x1fb8, 0x1fb9, 0x1fba, 0x1fbb, 0x1fbc, 0x1fbd, 0x1fbe, 0x1fbf,
0x7f00, 0x7f01, 0x7f02, 0x7f03, 0x7f04, 0x7f05, 0x7f06, 0x7f07, 0x7f00, 0x7f01, 0x7f02, 0x7f03, 0x7f04, 0x7f05, 0x7f06, 0x7f07,
0x7f08, 0x7f09, 0x7f0a, 0x7f0b, 0x7f0c, 0x7f0d, 0x7f0e, 0x7f0f, 0x7f08, 0x7f09, 0x7f0a, 0x7f0b, 0x7f0c, 0x7f0d, 0x7f0e, 0x7f0f,
0x7f10, 0x7f11, 0x7f12, 0x7f13, 0x7f14, 0x7f15, 0x7f16, 0x7f17, 0x7f10, 0x7f11, 0x7f12, 0x7f13, 0x7f14, 0x7f15, 0x7f16, 0x7f17,
0x7f18, 0x7f19, 0x7f1a, 0x7f1b, 0x7f1c, 0x7f1d, 0x7f1e, 0x7f1f, 0x7f18, 0x7f19, 0x7f1a, 0x7f1b, 0x7f1c, 0x7f1d, 0x7f1e, 0x7f1f,
0x7f20, 0x7f21, 0x7f22, 0x7f23, 0x7f24, 0x7f25, 0x7f26, 0x7f27, 0x7f20, 0x7f21, 0x7f22, 0x7f23, 0x7f24, 0x7f25, 0x7f26, 0x7f27,
0x7f28, 0x7f29, 0x7f2a, 0x7f2b, 0x7f2c, 0x7f2d, 0x7f2e, 0x7f2f, 0x7f28, 0x7f29, 0x7f2a, 0x7f2b, 0x7f2c, 0x7f2d, 0x7f2e, 0x7f2f,
0x7f30, 0x7f31, 0x7f32, 0x7f33, 0x7f34, 0x7f35, 0x7f36, 0x7f37, 0x7f30, 0x7f31, 0x7f32, 0x7f33, 0x7f34, 0x7f35, 0x7f36, 0x7f37,
0x7f38, 0x7f39, 0x7f3a, 0x7f3b, 0x7f3c, 0x7f3d, 0x7f3e, 0x7f3f, 0x7f38, 0x7f39, 0x7f3a, 0x7f3b, 0x7f3c, 0x7f3d, 0x7f3e, 0x7f3f,
0x7f40, 0x7f41, 0x7f42, 0x7f43, 0x7f44, 0x7f45, 0x7f46, 0x7f47, 0x7f40, 0x7f41, 0x7f42, 0x7f43, 0x7f44, 0x7f45, 0x7f46, 0x7f47,
0x7f48, 0x7f49, 0x7f4a, 0x7f4b, 0x7f4c, 0x7f4d, 0x7f4e, 0x7f4f, 0x7f48, 0x7f49, 0x7f4a, 0x7f4b, 0x7f4c, 0x7f4d, 0x7f4e, 0x7f4f,
0x7f50, 0x7f51, 0x7f52, 0x7f53, 0x7f54, 0x7f55, 0x7f56, 0x7f57, 0x7f50, 0x7f51, 0x7f52, 0x7f53, 0x7f54, 0x7f55, 0x7f56, 0x7f57,
0x7f58, 0x7f59, 0x7f5a, 0x7f5b, 0x7f5c, 0x7f5d, 0x7f5e, 0x7f5f, 0x7f58, 0x7f59, 0x7f5a, 0x7f5b, 0x7f5c, 0x7f5d, 0x7f5e, 0x7f5f,
0x7f60, 0x7f61, 0x7f62, 0x7f63, 0x7f64, 0x7f65, 0x7f66, 0x7f67, 0x7f60, 0x7f61, 0x7f62, 0x7f63, 0x7f64, 0x7f65, 0x7f66, 0x7f67,
0x7f68, 0x7f69, 0x7f6a, 0x7f6b, 0x7f6c, 0x7f6d, 0x7f6e, 0x7f6f, 0x7f68, 0x7f69, 0x7f6a, 0x7f6b, 0x7f6c, 0x7f6d, 0x7f6e, 0x7f6f,
0x7f70, 0x7f71, 0x7f72, 0x7f73, 0x7f74, 0x7f75, 0x7f76, 0x7f77, 0x7f70, 0x7f71, 0x7f72, 0x7f73, 0x7f74, 0x7f75, 0x7f76, 0x7f77,
0x7f78, 0x7f79, 0x7f7a, 0x7f7b, 0x7f7c, 0x7f7d, 0x7f7e, 0x7f7f, 0x7f78, 0x7f79, 0x7f7a, 0x7f7b, 0x7f7c, 0x7f7d, 0x7f7e, 0x7f7f,
0x7f80, 0x7f81, 0x7f82, 0x7f83, 0x7f84, 0x7f85, 0x7f86, 0x7f87, 0x7f80, 0x7f81, 0x7f82, 0x7f83, 0x7f84, 0x7f85, 0x7f86, 0x7f87,
0x7f88, 0x7f89, 0x7f8a, 0x7f8b, 0x7f8c, 0x7f8d, 0x7f8e, 0x7f8f, 0x7f88, 0x7f89, 0x7f8a, 0x7f8b, 0x7f8c, 0x7f8d, 0x7f8e, 0x7f8f,
0x7f90, 0x7f91, 0x7f92, 0x7f93, 0x7f94, 0x7f95, 0x7f96, 0x7f97, 0x7f90, 0x7f91, 0x7f92, 0x7f93, 0x7f94, 0x7f95, 0x7f96, 0x7f97,
0x7f98, 0x7f99, 0x7f9a, 0x7f9b, 0x7f9c, 0x7f9d, 0x7f9e, 0x7f9f, 0x7f98, 0x7f99, 0x7f9a, 0x7f9b, 0x7f9c, 0x7f9d, 0x7f9e, 0x7f9f,
0x7fa0, 0x7fa1, 0x7fa2, 0x7fa3, 0x7fa4, 0x7fa5, 0x7fa6, 0x7fa7, 0x7fa0, 0x7fa1, 0x7fa2, 0x7fa3, 0x7fa4, 0x7fa5, 0x7fa6, 0x7fa7,
0x7fa8, 0x7fa9, 0x7faa, 0x7fab, 0x7fac, 0x7fad, 0x7fae, 0x7faf, 0x7fa8, 0x7fa9, 0x7faa, 0x7fab, 0x7fac, 0x7fad, 0x7fae, 0x7faf,
0x7fb0, 0x7fb1, 0x7fb2, 0x7fb3, 0x7fb4, 0x7fb5, 0x7fb6, 0x7fb7, 0x7fb0, 0x7fb1, 0x7fb2, 0x7fb3, 0x7fb4, 0x7fb5, 0x7fb6, 0x7fb7,
0x7fb8, 0x7fb9, 0x7fba, 0x7fbb, 0x7fbc, 0x7fbd, 0x7fbe, 0x7fbf, 0x7fb8, 0x7fb9, 0x7fba, 0x7fbb, 0x7fbc, 0x7fbd, 0x7fbe, 0x7fbf,
0x7fc0, 0x7fc1, 0x7fc2, 0x7fc3, 0x7fc4, 0x7fc5, 0x7fc6, 0x7fc7, 0x7fc0, 0x7fc1, 0x7fc2, 0x7fc3, 0x7fc4, 0x7fc5, 0x7fc6, 0x7fc7,
0x7fc8, 0x7fc9, 0x7fca, 0x7fcb, 0x7fcc, 0x7fcd, 0x7fce, 0x7fcf, 0x7fc8, 0x7fc9, 0x7fca, 0x7fcb, 0x7fcc, 0x7fcd, 0x7fce, 0x7fcf,
0x7fd0, 0x7fd1, 0x7fd2, 0x7fd3, 0x7fd4, 0x7fd5, 0x7fd6, 0x7fd7, 0x7fd0, 0x7fd1, 0x7fd2, 0x7fd3, 0x7fd4, 0x7fd5, 0x7fd6, 0x7fd7,
0x7fd8, 0x7fd9, 0x7fda, 0x7fdb, 0x7fdc, 0x7fdd, 0x7fde, 0x7fdf, 0x7fd8, 0x7fd9, 0x7fda, 0x7fdb, 0x7fdc, 0x7fdd, 0x7fde, 0x7fdf,
0x7fe0, 0x7fe1, 0x7fe2, 0x7fe3, 0x7fe4, 0x7fe5, 0x7fe6, 0x7fe7, 0x7fe0, 0x7fe1, 0x7fe2, 0x7fe3, 0x7fe4, 0x7fe5, 0x7fe6, 0x7fe7,
0x7fe8, 0x7fe9, 0x7fea, 0x7feb, 0x7fec, 0x7fed, 0x7fee, 0x7fef, 0x7fe8, 0x7fe9, 0x7fea, 0x7feb, 0x7fec, 0x7fed, 0x7fee, 0x7fef,
0x7ff0, 0x7ff1, 0x7ff2, 0x7ff3, 0x7ff4, 0x7ff5, 0x7ff6, 0x7ff7, 0x7ff0, 0x7ff1, 0x7ff2, 0x7ff3, 0x7ff4, 0x7ff5, 0x7ff6, 0x7ff7,
0x7ff8, 0x7ff9, 0x7ffa, 0x7ffb, 0x7ffc, 0x7ffd, 0x7ffe, 0x7fff, 0x7ff8, 0x7ff9, 0x7ffa, 0x7ffb, 0x7ffc, 0x7ffd, 0x7ffe, 0x7fff,
0x0006, 0x0006,
}; };
const uint8_t ff_dv_vlc_len[NB_DV_VLC] = { const uint8_t ff_dv_vlc_len[NB_DV_VLC] = {
2, 3, 4, 4, 4, 5, 5, 5, 2, 3, 4, 4, 4, 5, 5, 5,
5, 6, 6, 6, 6, 7, 7, 7, 5, 6, 6, 6, 6, 7, 7, 7,
7, 7, 7, 7, 7, 8, 8, 8, 7, 7, 7, 7, 7, 8, 8, 8,
8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
8, 8, 8, 8, 8, 9, 9, 9, 8, 8, 8, 8, 8, 9, 9, 9,
9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
9, 9, 9, 9, 9, 10, 10, 10, 9, 9, 9, 9, 9, 10, 10, 10,
10, 10, 10, 10, 11, 11, 11, 11, 10, 10, 10, 10, 11, 11, 11, 11,
11, 11, 11, 11, 12, 12, 12, 12, 11, 11, 11, 11, 12, 12, 12, 12,
12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
4, 4,
}; };
const uint8_t ff_dv_vlc_run[NB_DV_VLC] = { const uint8_t ff_dv_vlc_run[NB_DV_VLC] = {
0, 0, 1, 0, 0, 2, 1, 0, 0, 0, 1, 0, 0, 2, 1, 0,
0, 3, 4, 0, 0, 5, 6, 2, 0, 3, 4, 0, 0, 5, 6, 2,
1, 1, 0, 0, 0, 7, 8, 9, 1, 1, 0, 0, 0, 7, 8, 9,
10, 3, 4, 2, 1, 1, 1, 0, 10, 3, 4, 2, 1, 1, 1, 0,
0, 0, 0, 0, 0, 11, 12, 13, 0, 0, 0, 0, 0, 11, 12, 13,
14, 5, 6, 3, 4, 2, 2, 1, 14, 5, 6, 3, 4, 2, 2, 1,
0, 0, 0, 0, 0, 5, 3, 3, 0, 0, 0, 0, 0, 5, 3, 3,
2, 1, 1, 1, 0, 1, 6, 4, 2, 1, 1, 1, 0, 1, 6, 4,
3, 1, 1, 1, 2, 3, 4, 5, 3, 1, 1, 1, 2, 3, 4, 5,
7, 8, 9, 10, 7, 8, 4, 3, 7, 8, 9, 10, 7, 8, 4, 3,
2, 2, 2, 2, 2, 1, 1, 1, 2, 2, 2, 2, 2, 1, 1, 1,
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,
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, 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, 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, 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,
127, 127,
}; };
const uint8_t ff_dv_vlc_level[NB_DV_VLC] = { const uint8_t ff_dv_vlc_level[NB_DV_VLC] = {
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,
128, 129, 130, 131, 132, 133, 134, 135, 128, 129, 130, 131, 132, 133, 134, 135,
136, 137, 138, 139, 140, 141, 142, 143, 136, 137, 138, 139, 140, 141, 142, 143,
144, 145, 146, 147, 148, 149, 150, 151, 144, 145, 146, 147, 148, 149, 150, 151,
152, 153, 154, 155, 156, 157, 158, 159, 152, 153, 154, 155, 156, 157, 158, 159,
160, 161, 162, 163, 164, 165, 166, 167, 160, 161, 162, 163, 164, 165, 166, 167,
168, 169, 170, 171, 172, 173, 174, 175, 168, 169, 170, 171, 172, 173, 174, 175,
176, 177, 178, 179, 180, 181, 182, 183, 176, 177, 178, 179, 180, 181, 182, 183,
184, 185, 186, 187, 188, 189, 190, 191, 184, 185, 186, 187, 188, 189, 190, 191,
192, 193, 194, 195, 196, 197, 198, 199, 192, 193, 194, 195, 196, 197, 198, 199,
200, 201, 202, 203, 204, 205, 206, 207, 200, 201, 202, 203, 204, 205, 206, 207,
208, 209, 210, 211, 212, 213, 214, 215, 208, 209, 210, 211, 212, 213, 214, 215,
216, 217, 218, 219, 220, 221, 222, 223, 216, 217, 218, 219, 220, 221, 222, 223,
224, 225, 226, 227, 228, 229, 230, 231, 224, 225, 226, 227, 228, 229, 230, 231,
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,
}; };

162
libavcodec/dvdec.c
Unescape View File

@ -35,17 +35,18 @@
* DV decoder * DV decoder
*/ */
#include "libavutil/internal.h"
#include "libavutil/imgutils.h" #include "libavutil/imgutils.h"
#include "libavutil/internal.h"
#include "libavutil/pixdesc.h" #include "libavutil/pixdesc.h"
#include "avcodec.h" #include "avcodec.h"
#include "dv.h"
#include "dvdata.h"
#include "get_bits.h"
#include "idctdsp.h" #include "idctdsp.h"
#include "internal.h" #include "internal.h"
#include "get_bits.h"
#include "put_bits.h" #include "put_bits.h"
#include "simple_idct.h" #include "simple_idct.h"
#include "dvdata.h"
#include "dv.h"
typedef struct BlockInfo { typedef struct BlockInfo {
const uint32_t *factor_table; const uint32_t *factor_table;
@ -68,7 +69,7 @@ static av_cold int dvvideo_decode_init(AVCodecContext *avctx)
ff_idctdsp_init(&idsp, avctx); ff_idctdsp_init(&idsp, avctx);
for (i = 0; i < 64; i++) for (i = 0; i < 64; i++)
s->dv_zigzag[0][i] = idsp.idct_permutation[ff_zigzag_direct[i]]; s->dv_zigzag[0][i] = idsp.idct_permutation[ff_zigzag_direct[i]];
memcpy(s->dv_zigzag[1], ff_dv_zigzag248_direct, sizeof(s->dv_zigzag[1])); memcpy(s->dv_zigzag[1], ff_dv_zigzag248_direct, sizeof(s->dv_zigzag[1]));
@ -84,8 +85,8 @@ static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, int16_t *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;
OPEN_READER_NOSIZE(re, gb); OPEN_READER_NOSIZE(re, gb);
@ -93,8 +94,9 @@ static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, int16_t *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 = re_cache >> partial_bit_count | mb->partial_bit_buffer; re_cache = re_cache >> partial_bit_count |
re_index -= partial_bit_count; mb->partial_bit_buffer;
re_index -= partial_bit_count;
mb->partial_bit_count = 0; mb->partial_bit_count = 0;
} }
@ -106,7 +108,7 @@ static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, int16_t *block)
index = NEG_USR32(re_cache, TEX_VLC_BITS); index = NEG_USR32(re_cache, TEX_VLC_BITS);
vlc_len = ff_dv_rl_vlc[index].len; vlc_len = ff_dv_rl_vlc[index].len;
if (vlc_len < 0) { if (vlc_len < 0) {
index = NEG_USR32((unsigned)re_cache << TEX_VLC_BITS, -vlc_len) + index = NEG_USR32((unsigned) re_cache << TEX_VLC_BITS, -vlc_len) +
ff_dv_rl_vlc[index].level; ff_dv_rl_vlc[index].level;
vlc_len = TEX_VLC_BITS - vlc_len; vlc_len = TEX_VLC_BITS - vlc_len;
} }
@ -116,9 +118,9 @@ static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, int16_t *block)
/* 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) {
/* should be < 16 bits otherwise a codeword could have been parsed */ /* should be < 16 bits otherwise a codeword could have been parsed */
mb->partial_bit_count = last_index - re_index; mb->partial_bit_count = last_index - re_index;
mb->partial_bit_buffer = re_cache & ~(-1u >> mb->partial_bit_count); mb->partial_bit_buffer = re_cache & ~(-1u >> mb->partial_bit_count);
re_index = last_index; re_index = last_index;
break; break;
} }
re_index += vlc_len; re_index += vlc_len;
@ -128,7 +130,8 @@ static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, int16_t *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);
@ -144,9 +147,8 @@ static inline void bit_copy(PutBitContext *pb, GetBitContext *gb)
put_bits(pb, MIN_CACHE_BITS, get_bits(gb, MIN_CACHE_BITS)); put_bits(pb, MIN_CACHE_BITS, get_bits(gb, MIN_CACHE_BITS));
bits_left -= MIN_CACHE_BITS; bits_left -= MIN_CACHE_BITS;
} }
if (bits_left > 0) { if (bits_left > 0)
put_bits(pb, bits_left, get_bits(gb, bits_left)); put_bits(pb, bits_left, get_bits(gb, bits_left));
}
} }
/* mb_x and mb_y are in units of 8 pixels */ /* mb_x and mb_y are in units of 8 pixels */
@ -164,25 +166,25 @@ static int dv_decode_video_segment(AVCodecContext *avctx, void *arg)
PutBitContext pb, vs_pb; PutBitContext pb, vs_pb;
GetBitContext gb; GetBitContext gb;
BlockInfo mb_data[5 * DV_MAX_BPM], *mb, *mb1; BlockInfo mb_data[5 * DV_MAX_BPM], *mb, *mb1;
LOCAL_ALIGNED_16(int16_t, sblock, [5*DV_MAX_BPM], [64]); LOCAL_ALIGNED_16(int16_t, sblock, [5 * DV_MAX_BPM], [64]);
LOCAL_ALIGNED_16(uint8_t, mb_bit_buffer, [ 80 + FF_INPUT_BUFFER_PADDING_SIZE]); /* allow some slack */ LOCAL_ALIGNED_16(uint8_t, mb_bit_buffer, [80 + FF_INPUT_BUFFER_PADDING_SIZE]); /* allow some slack */
LOCAL_ALIGNED_16(uint8_t, vs_bit_buffer, [5*80 + FF_INPUT_BUFFER_PADDING_SIZE]); /* allow some slack */ LOCAL_ALIGNED_16(uint8_t, vs_bit_buffer, [80 * 5 + FF_INPUT_BUFFER_PADDING_SIZE]); /* allow some slack */
const int log2_blocksize = 3; const int log2_blocksize = 3;
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, 5*DV_MAX_BPM*sizeof(*sblock)); memset(sblock, 0, 5 * DV_MAX_BPM * sizeof(*sblock));
/* pass 1: read DC and AC coefficients in blocks */ /* pass 1: read DC and AC coefficients in blocks */
buf_ptr = &s->buf[work_chunk->buf_offset*80]; buf_ptr = &s->buf[work_chunk->buf_offset * 80];
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;
@ -199,20 +201,24 @@ static int dv_decode_video_segment(AVCodecContext *avctx, void *arg)
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->idct_factor[(j >= 4)*4*16*64 + class1*16*64 + quant*64]; mb->factor_table = &s->idct_factor[(j >= 4) * 4 * 16 * 64 +
class1 * 16 * 64 +
quant * 64];
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->idct_factor[(class1 == 3)*2*22*64 + dct_mode*22*64 + mb->factor_table =
(quant + ff_dv_quant_offset[class1])*64]; &s->idct_factor[(class1 == 3) * 2 * 22 * 64 +
dct_mode * 22 * 64 +
(quant + ff_dv_quant_offset[class1]) * 64];
} }
dc = dc << 2; dc = dc << 2;
/* convert to unsigned because 128 is not added in the /* convert to unsigned because 128 is not added in the
standard IDCT */ * standard IDCT */
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;
@ -220,7 +226,7 @@ static int dv_decode_video_segment(AVCodecContext *avctx, void *arg)
dv_decode_ac(&gb, mb, block); dv_decode_ac(&gb, mb, block);
/* write the remaining bits in a new buffer only if the /* write the remaining bits in a new buffer only if the
block is finished */ * block is finished */
if (mb->pos >= 64) if (mb->pos >= 64)
bit_copy(&pb, &gb); bit_copy(&pb, &gb);
@ -244,7 +250,7 @@ static int dv_decode_video_segment(AVCodecContext *avctx, void *arg)
} }
} }
/* all blocks are finished, so the extra bytes can be used at /* all blocks are finished, so the extra bytes can be used at
the video segment level */ * the video segment level */
if (j >= s->sys->bpm) if (j >= s->sys->bpm)
bit_copy(&vs_pb, &gb); bit_copy(&vs_pb, &gb);
} }
@ -263,7 +269,8 @@ static int dv_decode_video_segment(AVCodecContext *avctx, void *arg)
dv_decode_ac(&gb, mb, block); dv_decode_ac(&gb, mb, block);
} }
if (mb->pos >= 64 && mb->pos < 127) if (mb->pos >= 64 && mb->pos < 127)
av_log(avctx, AV_LOG_ERROR, "AC EOB marker is absent pos=%d\n", mb->pos); av_log(avctx, AV_LOG_ERROR,
"AC EOB marker is absent pos=%d\n", mb->pos);
block += 64; block += 64;
mb++; mb++;
} }
@ -276,25 +283,27 @@ static int dv_decode_video_segment(AVCodecContext *avctx, void *arg)
dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y); dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
/* idct_put'ting luminance */ /* idct_put'ting luminance */
if ((s->sys->pix_fmt == AV_PIX_FMT_YUV420P) || if ((s->sys->pix_fmt == AV_PIX_FMT_YUV420P) ||
(s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) || (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
(s->sys->height >= 720 && mb_y != 134)) { (s->sys->height >= 720 && mb_y != 134)) {
y_stride = (s->frame->linesize[0] << ((!is_field_mode[mb_index]) * log2_blocksize)); y_stride = (s->frame->linesize[0] <<
((!is_field_mode[mb_index]) * log2_blocksize));
} else { } else {
y_stride = (2 << log2_blocksize); y_stride = (2 << log2_blocksize);
} }
y_ptr = s->frame->data[0] + ((mb_y * s->frame->linesize[0] + mb_x) << log2_blocksize); y_ptr = s->frame->data[0] +
((mb_y * s->frame->linesize[0] + mb_x) << log2_blocksize);
linesize = s->frame->linesize[0] << is_field_mode[mb_index]; linesize = s->frame->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 == AV_PIX_FMT_YUV420P)) * s->frame->linesize[1] + c_offset = (((mb_y >> (s->sys->pix_fmt == AV_PIX_FMT_YUV420P)) * s->frame->linesize[1] +
@ -302,28 +311,31 @@ static int dv_decode_video_segment(AVCodecContext *avctx, void *arg)
for (j = 2; j; j--) { for (j = 2; j; j--) {
uint8_t *c_ptr = s->frame->data[j] + c_offset; uint8_t *c_ptr = s->frame->data[j] + c_offset;
if (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) { if (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
uint64_t aligned_pixels[64/8]; uint64_t aligned_pixels[64 / 8];
uint8_t *pixels = (uint8_t*)aligned_pixels; uint8_t *pixels = (uint8_t *) aligned_pixels;
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->frame->linesize[j], pixels += 8) { for (y = 0; y < (1 << log2_blocksize); y++, c_ptr += s->frame->linesize[j], pixels += 8) {
ptr1 = pixels + (1 << (log2_blocksize - 1)); ptr1 = pixels + (1 << (log2_blocksize - 1));
c_ptr1 = c_ptr + (s->frame->linesize[j] << log2_blocksize); c_ptr1 = c_ptr + (s->frame->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->frame->linesize[j] << ((!is_field_mode[mb_index]) * log2_blocksize); s->frame->linesize[j] << ((!is_field_mode[mb_index]) * log2_blocksize);
linesize = s->frame->linesize[j] << is_field_mode[mb_index]; linesize = s->frame->linesize[j] << is_field_mode[mb_index];
(mb++)-> idct_put(c_ptr , linesize, block); block += 64; (mb++)->idct_put(c_ptr, linesize, block);
if (s->sys->bpm == 8) { block += 64;
(mb++)->idct_put(c_ptr + y_stride, linesize, block); block += 64; if (s->sys->bpm == 8) {
} (mb++)->idct_put(c_ptr + y_stride, linesize, block);
block += 64;
}
} }
} }
} }
@ -331,15 +343,14 @@ static int dv_decode_video_segment(AVCodecContext *avctx, void *arg)
} }
/* NOTE: exactly one frame must be given (120000 bytes for NTSC, /* NOTE: exactly one frame must be given (120000 bytes for NTSC,
144000 bytes for PAL - or twice those for 50Mbps) */ * 144000 bytes for PAL - or twice those for 50Mbps) */
static int dvvideo_decode_frame(AVCodecContext *avctx, static int dvvideo_decode_frame(AVCodecContext *avctx, void *data,
void *data, int *got_frame, int *got_frame, AVPacket *avpkt)
AVPacket *avpkt)
{ {
uint8_t *buf = avpkt->data; uint8_t *buf = avpkt->data;
int buf_size = avpkt->size; int buf_size = avpkt->size;
DVVideoContext *s = avctx->priv_data; DVVideoContext *s = avctx->priv_data;
const uint8_t* vsc_pack; const uint8_t *vsc_pack;
int apt, is16_9, ret; int apt, is16_9, ret;
const AVDVProfile *sys; const AVDVProfile *sys;
@ -361,18 +372,19 @@ static int dvvideo_decode_frame(AVCodecContext *avctx,
s->frame = data; s->frame = data;
s->frame->key_frame = 1; s->frame->key_frame = 1;
s->frame->pict_type = AV_PICTURE_TYPE_I; s->frame->pict_type = AV_PICTURE_TYPE_I;
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;
ret = ff_set_dimensions(avctx, s->sys->width, s->sys->height); ret = ff_set_dimensions(avctx, s->sys->width, s->sys->height);
if (ret < 0) if (ret < 0)
return ret; return ret;
/* Determine the codec's sample_aspect ratio from the packet */ /* Determine the codec's sample_aspect ratio from the packet */
vsc_pack = buf + 80*5 + 48 + 5; vsc_pack = buf + 80 * 5 + 48 + 5;
if ( *vsc_pack == dv_video_control ) { if (*vsc_pack == dv_video_control) {
apt = buf[4] & 0x07; apt = buf[4] & 0x07;
is16_9 = (vsc_pack && ((vsc_pack[2] & 0x07) == 0x02 || (!apt && (vsc_pack[2] & 0x07) == 0x07))); is16_9 = (vsc_pack && ((vsc_pack[2] & 0x07) == 0x02 ||
(!apt && (vsc_pack[2] & 0x07) == 0x07)));
ff_set_sar(avctx, s->sys->sar[is16_9]); ff_set_sar(avctx, s->sys->sar[is16_9]);
} }

593
libavcodec/dvenc.c
Unescape View File

@ -24,18 +24,20 @@
* DV encoder * DV encoder
*/ */
#include "config.h"
#include "libavutil/attributes.h" #include "libavutil/attributes.h"
#include "libavutil/pixdesc.h" #include "libavutil/pixdesc.h"
#include "config.h"
#include "avcodec.h" #include "avcodec.h"
#include "dv.h"
#include "dv_profile_internal.h"
#include "dv_tablegen.h"
#include "fdctdsp.h" #include "fdctdsp.h"
#include "internal.h" #include "internal.h"
#include "me_cmp.h" #include "me_cmp.h"
#include "pixblockdsp.h" #include "pixblockdsp.h"
#include "put_bits.h" #include "put_bits.h"
#include "dv.h"
#include "dv_tablegen.h"
#include "dv_profile_internal.h"
static av_cold int dvvideo_encode_init(AVCodecContext *avctx) static av_cold int dvvideo_encode_init(AVCodecContext *avctx)
{ {
@ -48,7 +50,7 @@ static av_cold int dvvideo_encode_init(AVCodecContext *avctx)
s->sys = av_dv_codec_profile(avctx->width, avctx->height, avctx->pix_fmt); s->sys = av_dv_codec_profile(avctx->width, avctx->height, avctx->pix_fmt);
if (!s->sys) { if (!s->sys) {
av_log(avctx, AV_LOG_ERROR, "Found no DV profile for %ix%i %s video. " av_log(avctx, AV_LOG_ERROR, "Found no DV profile for %ix%i %s video. "
"Valid DV profiles are:\n", "Valid DV profiles are:\n",
avctx->width, avctx->height, av_get_pix_fmt_name(avctx->pix_fmt)); avctx->width, avctx->height, av_get_pix_fmt_name(avctx->pix_fmt));
ff_dv_print_profiles(avctx, AV_LOG_ERROR); ff_dv_print_profiles(avctx, AV_LOG_ERROR);
return AVERROR(EINVAL); return AVERROR(EINVAL);
@ -80,19 +82,19 @@ static av_cold int dvvideo_encode_init(AVCodecContext *avctx)
} }
/* bit budget for AC only in 5 MBs */ /* bit budget for AC only in 5 MBs */
static const int vs_total_ac_bits = (100 * 4 + 68*2) * 5; static const int vs_total_ac_bits = (100 * 4 + 68 * 2) * 5;
static const int mb_area_start[5] = { 1, 6, 21, 43, 64 }; static const int mb_area_start[5] = { 1, 6, 21, 43, 64 };
#if CONFIG_SMALL #if CONFIG_SMALL
/* Converts run and level (where level != 0) pair into VLC, returning bit size */ /* Convert run and level (where level != 0) pair into VLC, returning bit size */
static av_always_inline int dv_rl2vlc(int run, int level, int sign, uint32_t* vlc) static av_always_inline int dv_rl2vlc(int run, int level, int sign,
uint32_t *vlc)
{ {
int size; int size;
if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) { if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
*vlc = dv_vlc_map[run][level].vlc | sign; *vlc = dv_vlc_map[run][level].vlc | sign;
size = dv_vlc_map[run][level].size; size = dv_vlc_map[run][level].size;
} } else {
else {
if (level < DV_VLC_MAP_LEV_SIZE) { if (level < DV_VLC_MAP_LEV_SIZE) {
*vlc = dv_vlc_map[0][level].vlc | sign; *vlc = dv_vlc_map[0][level].vlc | sign;
size = dv_vlc_map[0][level].size; size = dv_vlc_map[0][level].size;
@ -101,9 +103,9 @@ static av_always_inline int dv_rl2vlc(int run, int level, int sign, uint32_t* vl
size = 16; size = 16;
} }
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;
} }
} }
@ -116,17 +118,15 @@ static av_always_inline int dv_rl2vlc_size(int run, int level)
if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) { if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
size = dv_vlc_map[run][level].size; size = dv_vlc_map[run][level].size;
} } else {
else {
size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16; size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16;
if (run) { if (run)
size += (run < 16) ? dv_vlc_map[run-1][0].size : 13; size += (run < 16) ? dv_vlc_map[run - 1][0].size : 13;
}
} }
return size; return size;
} }
#else #else
static av_always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t* vlc) static av_always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t *vlc)
{ {
*vlc = dv_vlc_map[run][l].vlc | sign; *vlc = dv_vlc_map[run][l].vlc | sign;
return dv_vlc_map[run][l].size; return dv_vlc_map[run][l].size;
@ -152,55 +152,60 @@ typedef struct EncBlockInfo {
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, static av_always_inline PutBitContext *dv_encode_ac(EncBlockInfo *bi,
PutBitContext* pb_pool, PutBitContext *pb_pool,
PutBitContext* pb_end) PutBitContext *pb_end)
{ {
int prev, bits_left; int prev, 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 =
for (;;){ bi->partial_bit_buffer = 0;
/* Find suitable storage space */ for (;;) {
for (; size > (bits_left = put_bits_left(pb)); pb++) { /* Find suitable storage space */
if (bits_left) { for (; size > (bits_left = put_bits_left(pb)); pb++) {
size -= bits_left; if (bits_left) {
put_bits(pb, bits_left, vlc >> size); size -= bits_left;
vlc = vlc & ((1 << size) - 1); put_bits(pb, bits_left, vlc >> size);
} vlc = vlc & ((1 << size) - 1);
if (pb + 1 >= pb_end) { }
bi->partial_bit_count = size; if (pb + 1 >= pb_end) {
bi->partial_bit_buffer = vlc; bi->partial_bit_count = size;
return pb; bi->partial_bit_buffer = vlc;
} return pb;
} }
}
/* Store VLC */
put_bits(pb, size, vlc); /* Store VLC */
put_bits(pb, size, vlc);
if (bi->cur_ac >= 64)
break; if (bi->cur_ac >= 64)
break;
/* Construct the next VLC */
prev = bi->cur_ac; /* Construct the next VLC */
bi->cur_ac = bi->next[prev]; prev = bi->cur_ac;
if (bi->cur_ac < 64){ bi->cur_ac = bi->next[prev];
size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac], bi->sign[bi->cur_ac], &vlc); if (bi->cur_ac < 64) {
} else { size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac],
size = 4; vlc = 6; /* End Of Block stamp */ bi->sign[bi->cur_ac], &vlc);
} } else {
size = 4;
vlc = 6; /* End Of Block stamp */
}
} }
return pb; return pb;
} }
static av_always_inline int dv_guess_dct_mode(DVVideoContext *s, uint8_t *data, int linesize) { static av_always_inline int dv_guess_dct_mode(DVVideoContext *s, uint8_t *data,
int linesize)
{
if (s->avctx->flags & CODEC_FLAG_INTERLACED_DCT) { if (s->avctx->flags & CODEC_FLAG_INTERLACED_DCT) {
int ps = s->ildct_cmp(NULL, data, NULL, linesize, 8) - 400; int ps = s->ildct_cmp(NULL, data, NULL, linesize, 8) - 400;
if (ps > 0) { if (ps > 0) {
int is = s->ildct_cmp(NULL, data , NULL, linesize<<1, 4) + int is = s->ildct_cmp(NULL, data, NULL, linesize << 1, 4) +
s->ildct_cmp(NULL, data + linesize, NULL, linesize<<1, 4); s->ildct_cmp(NULL, data + linesize, NULL, linesize << 1, 4);
return ps > is; return ps > is;
} }
} }
@ -210,94 +215,102 @@ static av_always_inline int dv_guess_dct_mode(DVVideoContext *s, uint8_t *data,
static const int dv_weight_bits = 18; static const int dv_weight_bits = 18;
static const int dv_weight_88[64] = { static const int dv_weight_88[64] = {
131072, 257107, 257107, 242189, 252167, 242189, 235923, 237536, 131072, 257107, 257107, 242189, 252167, 242189, 235923, 237536,
237536, 235923, 229376, 231390, 223754, 231390, 229376, 222935, 237536, 235923, 229376, 231390, 223754, 231390, 229376, 222935,
224969, 217965, 217965, 224969, 222935, 200636, 218652, 211916, 224969, 217965, 217965, 224969, 222935, 200636, 218652, 211916,
212325, 211916, 218652, 200636, 188995, 196781, 205965, 206433, 212325, 211916, 218652, 200636, 188995, 196781, 205965, 206433,
206433, 205965, 196781, 188995, 185364, 185364, 200636, 200704, 206433, 205965, 196781, 188995, 185364, 185364, 200636, 200704,
200636, 185364, 185364, 174609, 180568, 195068, 195068, 180568, 200636, 185364, 185364, 174609, 180568, 195068, 195068, 180568,
174609, 170091, 175557, 189591, 175557, 170091, 165371, 170627, 174609, 170091, 175557, 189591, 175557, 170091, 165371, 170627,
170627, 165371, 160727, 153560, 160727, 144651, 144651, 136258, 170627, 165371, 160727, 153560, 160727, 144651, 144651, 136258,
}; };
static const int dv_weight_248[64] = { static const int dv_weight_248[64] = {
131072, 242189, 257107, 237536, 229376, 200636, 242189, 223754, 131072, 242189, 257107, 237536, 229376, 200636, 242189, 223754,
224969, 196781, 262144, 242189, 229376, 200636, 257107, 237536, 224969, 196781, 262144, 242189, 229376, 200636, 257107, 237536,
211916, 185364, 235923, 217965, 229376, 211916, 206433, 180568, 211916, 185364, 235923, 217965, 229376, 211916, 206433, 180568,
242189, 223754, 224969, 196781, 211916, 185364, 235923, 217965, 242189, 223754, 224969, 196781, 211916, 185364, 235923, 217965,
200704, 175557, 222935, 205965, 200636, 185364, 195068, 170627, 200704, 175557, 222935, 205965, 200636, 185364, 195068, 170627,
229376, 211916, 206433, 180568, 200704, 175557, 222935, 205965, 229376, 211916, 206433, 180568, 200704, 175557, 222935, 205965,
175557, 153560, 188995, 174609, 165371, 144651, 200636, 185364, 175557, 153560, 188995, 174609, 165371, 144651, 200636, 185364,
195068, 170627, 175557, 153560, 188995, 174609, 165371, 144651, 195068, 170627, 175557, 153560, 188995, 174609, 165371, 144651,
}; };
static av_always_inline int dv_init_enc_block(EncBlockInfo* bi, uint8_t *data, int linesize, DVVideoContext *s, int bias) static av_always_inline int dv_init_enc_block(EncBlockInfo *bi, uint8_t *data,
int linesize, DVVideoContext *s,
int bias)
{ {
const int *weight; const int *weight;
const uint8_t* zigzag_scan; const uint8_t *zigzag_scan;
LOCAL_ALIGNED_16(int16_t, blk, [64]); LOCAL_ALIGNED_16(int16_t, blk, [64]);
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
method suggested in SMPTE 314M Table 22, and an improved * method suggested in SMPTE 314M Table 22, and an improved
method. The SMPTE method is very conservative; it assigns class * method. The SMPTE method is very conservative; it assigns class
3 (i.e. severe quantization) to any block where the largest AC * 3 (i.e. severe quantization) to any block where the largest AC
component is greater than 36. Libav's DV encoder tracks AC bit * component is greater than 36. Libav's DV encoder tracks AC bit
consumption precisely, so there is no need to bias most blocks * consumption precisely, so there is no need to bias most blocks
towards strongly lossy compression. Instead, we assign class 2 * towards strongly lossy compression. Instead, we assign class 2
to most blocks, and use class 3 only when strictly necessary * to most blocks, and use class 3 only when strictly necessary
(for blocks whose largest AC component exceeds 255). */ * (for blocks whose largest AC component exceeds 255). */
#if 0 /* SMPTE spec method */ #if 0 /* SMPTE spec method */
static const int classes[] = {12, 24, 36, 0xffff}; static const int classes[] = { 12, 24, 36, 0xffff };
#else /* improved Libav method */ #else /* improved Libav 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;
assert((((int)blk) & 15) == 0); assert((((int) blk) & 15) == 0);
bi->area_q[0] = bi->area_q[1] = bi->area_q[2] = bi->area_q[3] = 0; bi->area_q[0] =
bi->partial_bit_count = 0; bi->area_q[1] =
bi->area_q[2] =
bi->area_q[3] = 0;
bi->partial_bit_count = 0;
bi->partial_bit_buffer = 0; bi->partial_bit_buffer = 0;
bi->cur_ac = 0; bi->cur_ac = 0;
if (data) { if (data) {
bi->dct_mode = dv_guess_dct_mode(s, data, linesize); bi->dct_mode = dv_guess_dct_mode(s, data, linesize);
s->get_pixels(blk, data, linesize); s->get_pixels(blk, data, linesize);
s->fdct[bi->dct_mode](blk); s->fdct[bi->dct_mode](blk);
} else { } else {
/* We rely on the fact that encoding all zeros leads to an immediate EOB, /* We rely on the fact that encoding all zeros leads to an immediate
which is precisely what the spec calls for in the "dummy" blocks. */ * EOB, which is precisely what the spec calls for in the "dummy"
memset(blk, 0, 64*sizeof(*blk)); * blocks. */
memset(blk, 0, 64 * sizeof(*blk));
bi->dct_mode = 0; bi->dct_mode = 0;
} }
bi->mb[0] = blk[0]; bi->mb[0] = blk[0];
zigzag_scan = bi->dct_mode ? ff_dv_zigzag248_direct : ff_zigzag_direct; zigzag_scan = bi->dct_mode ? ff_dv_zigzag248_direct : ff_zigzag_direct;
weight = bi->dct_mode ? dv_weight_248 : dv_weight_88; weight = bi->dct_mode ? dv_weight_248 : dv_weight_88;
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;
/* weight it and and shift down into range, adding for rounding */ /* Weight 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
AND the 2x doubling of the weights */ * 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))) >>
bi->mb[i] = level; (dv_weight_bits + 4);
if (level > max) bi->mb[i] = level;
max = level; if (level > max)
bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, level); max = level;
bi->next[prev]= i; bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, level);
prev = i; bi->next[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;
@ -308,85 +321,89 @@ static av_always_inline int dv_init_enc_block(EncBlockInfo* bi, uint8_t *data, i
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;
} }
} }
} }
bi->next[prev]= i; bi->next[prev] = i;
} }
return bi->bit_size[0] + bi->bit_size[1] + bi->bit_size[2] + bi->bit_size[3]; return bi->bit_size[0] + bi->bit_size[1] +
bi->bit_size[2] + bi->bit_size[3];
} }
static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos) static inline void dv_guess_qnos(EncBlockInfo *blks, int *qnos)
{ {
int size[5]; int size[5];
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] != ff_dv_quant_shifts[qnos[i] + ff_dv_quant_offset[b->cno]][a]) { if (b->area_q[a] != ff_dv_quant_shifts[qnos[i] + ff_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;
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));
b->prev[a2] = prev; b->prev[a2] = prev;
assert(a2 < 4); }
assert(b->mb[b->next[k]]); b->next[prev] = 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)); b->prev[a + 1] = prev;
b->prev[a2] = prev;
}
b->next[prev] = b->next[k];
}
} }
b->prev[a+1]= prev; 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;
} }
} }
} }
@ -399,45 +416,46 @@ static int dv_encode_video_segment(AVCodecContext *avctx, void *arg)
DVwork_chunk *work_chunk = arg; DVwork_chunk *work_chunk = arg;
int mb_index, i, j; int mb_index, i, j;
int mb_x, mb_y, c_offset, linesize, y_stride; int mb_x, mb_y, c_offset, linesize, y_stride;
uint8_t* y_ptr; uint8_t *y_ptr;
uint8_t* dif; uint8_t *dif;
LOCAL_ALIGNED_8(uint8_t, scratch, [128]); LOCAL_ALIGNED_8(uint8_t, scratch, [128]);
EncBlockInfo enc_blks[5*DV_MAX_BPM]; EncBlockInfo enc_blks[5 * DV_MAX_BPM];
PutBitContext pbs[5*DV_MAX_BPM]; PutBitContext pbs[5 * DV_MAX_BPM];
PutBitContext* pb; PutBitContext *pb;
EncBlockInfo* enc_blk; EncBlockInfo *enc_blk;
int vs_bit_size = 0; int vs_bit_size = 0;
int qnos[5] = {15, 15, 15, 15, 15}; /* No quantization */ int qnos[5] = { 15, 15, 15, 15, 15 }; /* No quantization */
int* qnosp = &qnos[0]; int *qnosp = &qnos[0];
dif = &s->buf[work_chunk->buf_offset*80]; dif = &s->buf[work_chunk->buf_offset * 80];
enc_blk = &enc_blks[0]; enc_blk = &enc_blks[0];
for (mb_index = 0; mb_index < 5; mb_index++) { for (mb_index = 0; mb_index < 5; mb_index++) {
dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y); dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
/* initializing luminance blocks */ /* initializing luminance blocks */
if ((s->sys->pix_fmt == AV_PIX_FMT_YUV420P) || if ((s->sys->pix_fmt == AV_PIX_FMT_YUV420P) ||
(s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) || (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
(s->sys->height >= 720 && mb_y != 134)) { (s->sys->height >= 720 && mb_y != 134)) {
y_stride = s->frame->linesize[0] << 3; y_stride = s->frame->linesize[0] << 3;
} else { } else {
y_stride = 16; y_stride = 16;
} }
y_ptr = s->frame->data[0] + ((mb_y * s->frame->linesize[0] + mb_x) << 3); y_ptr = s->frame->data[0] +
((mb_y * s->frame->linesize[0] + mb_x) << 3);
linesize = s->frame->linesize[0]; linesize = s->frame->linesize[0];
if (s->sys->video_stype == 4) { /* SD 422 */ if (s->sys->video_stype == 4) { /* SD 422 */
vs_bit_size += vs_bit_size +=
dv_init_enc_block(enc_blk+0, y_ptr , linesize, s, 0) + dv_init_enc_block(enc_blk + 0, y_ptr, linesize, s, 0) +
dv_init_enc_block(enc_blk+1, NULL , linesize, s, 0) + dv_init_enc_block(enc_blk + 1, NULL, linesize, s, 0) +
dv_init_enc_block(enc_blk+2, y_ptr + 8 , linesize, s, 0) + dv_init_enc_block(enc_blk + 2, y_ptr + 8, linesize, s, 0) +
dv_init_enc_block(enc_blk+3, NULL , linesize, s, 0); dv_init_enc_block(enc_blk + 3, NULL, linesize, s, 0);
} else { } else {
vs_bit_size += vs_bit_size +=
dv_init_enc_block(enc_blk+0, y_ptr , linesize, s, 0) + dv_init_enc_block(enc_blk + 0, y_ptr, linesize, s, 0) +
dv_init_enc_block(enc_blk+1, y_ptr + 8 , linesize, s, 0) + dv_init_enc_block(enc_blk + 1, y_ptr + 8, linesize, s, 0) +
dv_init_enc_block(enc_blk+2, y_ptr + y_stride, linesize, s, 0) + dv_init_enc_block(enc_blk + 2, y_ptr + y_stride, linesize, s, 0) +
dv_init_enc_block(enc_blk+3, y_ptr + 8 + y_stride, linesize, s, 0); dv_init_enc_block(enc_blk + 3, y_ptr + 8 + y_stride, linesize, s, 0);
} }
enc_blk += 4; enc_blk += 4;
@ -449,23 +467,29 @@ static int dv_encode_video_segment(AVCodecContext *avctx, void *arg)
linesize = s->frame->linesize[j]; linesize = s->frame->linesize[j];
y_stride = (mb_y == 134) ? 8 : (s->frame->linesize[j] << 3); y_stride = (mb_y == 134) ? 8 : (s->frame->linesize[j] << 3);
if (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) { if (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
uint8_t* d; uint8_t *d;
uint8_t* b = scratch; uint8_t *b = scratch;
for (i = 0; i < 8; i++) { for (i = 0; i < 8; i++) {
d = c_ptr + (linesize << 3); d = c_ptr + (linesize << 3);
b[0] = c_ptr[0]; b[1] = c_ptr[1]; b[2] = c_ptr[2]; b[3] = c_ptr[3]; b[0] = c_ptr[0];
b[4] = d[0]; b[5] = d[1]; b[6] = d[2]; b[7] = d[3]; b[1] = c_ptr[1];
b[2] = c_ptr[2];
b[3] = c_ptr[3];
b[4] = d[0];
b[5] = d[1];
b[6] = d[2];
b[7] = d[3];
c_ptr += linesize; c_ptr += linesize;
b += 16; b += 16;
} }
c_ptr = scratch; c_ptr = scratch;
linesize = 16; linesize = 16;
} }
vs_bit_size += dv_init_enc_block( enc_blk++, c_ptr , linesize, s, 1); vs_bit_size += dv_init_enc_block(enc_blk++, c_ptr, linesize, s, 1);
if (s->sys->bpm == 8) { if (s->sys->bpm == 8)
vs_bit_size += dv_init_enc_block(enc_blk++, c_ptr + y_stride, linesize, s, 1); vs_bit_size += dv_init_enc_block(enc_blk++, c_ptr + y_stride,
} linesize, s, 1);
} }
} }
@ -473,59 +497,60 @@ static int dv_encode_video_segment(AVCodecContext *avctx, void *arg)
dv_guess_qnos(&enc_blks[0], qnosp); dv_guess_qnos(&enc_blks[0], qnosp);
/* DIF encoding process */ /* DIF encoding process */
for (j=0; j<5*s->sys->bpm;) { for (j = 0; j < 5 * s->sys->bpm;) {
int start_mb = j; int start_mb = j;
dif[3] = *qnosp++; dif[3] = *qnosp++;
dif += 4; dif += 4;
/* First pass over individual cells only */ /* First pass over individual cells only */
for (i=0; i<s->sys->bpm; i++, j++) { for (i = 0; i < s->sys->bpm; i++, j++) {
int sz = s->sys->block_sizes[i]>>3; int sz = s->sys->block_sizes[i] >> 3;
init_put_bits(&pbs[j], dif, sz); init_put_bits(&pbs[j], dif, sz);
put_sbits(&pbs[j], 9, ((enc_blks[j].mb[0] >> 3) - 1024 + 2) >> 2); put_sbits(&pbs[j], 9, ((enc_blks[j].mb[0] >> 3) - 1024 + 2) >> 2);
put_bits(&pbs[j], 1, enc_blks[j].dct_mode); put_bits(&pbs[j], 1, enc_blks[j].dct_mode);
put_bits(&pbs[j], 2, enc_blks[j].cno); put_bits(&pbs[j], 2, enc_blks[j].cno);
dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j+1]); dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j + 1]);
dif += sz; dif += sz;
} }
/* Second pass over each MB space */ /* Second pass over each MB space */
pb = &pbs[start_mb]; pb = &pbs[start_mb];
for (i=0; i<s->sys->bpm; i++) { for (i = 0; i < s->sys->bpm; i++)
if (enc_blks[start_mb+i].partial_bit_count) if (enc_blks[start_mb + i].partial_bit_count)
pb = dv_encode_ac(&enc_blks[start_mb+i], pb, &pbs[start_mb+s->sys->bpm]); pb = dv_encode_ac(&enc_blks[start_mb + i], pb,
} &pbs[start_mb + s->sys->bpm]);
} }
/* 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*s->sys->bpm; j++) { for (j = 0; j < 5 * s->sys->bpm; j++) {
if (enc_blks[j].partial_bit_count) if (enc_blks[j].partial_bit_count)
pb = dv_encode_ac(&enc_blks[j], pb, &pbs[s->sys->bpm*5]); pb = dv_encode_ac(&enc_blks[j], pb, &pbs[s->sys->bpm * 5]);
if (enc_blks[j].partial_bit_count) if (enc_blks[j].partial_bit_count)
av_log(avctx, AV_LOG_ERROR, "ac bitstream overflow\n"); av_log(avctx, AV_LOG_ERROR, "ac bitstream overflow\n");
} }
for (j=0; j<5*s->sys->bpm; j++) { for (j = 0; j < 5 * s->sys->bpm; j++) {
int pos; int pos;
int size = pbs[j].size_in_bits >> 3; int size = pbs[j].size_in_bits >> 3;
flush_put_bits(&pbs[j]); flush_put_bits(&pbs[j]);
pos = put_bits_count(&pbs[j]) >> 3; pos = put_bits_count(&pbs[j]) >> 3;
if (pos > size) { if (pos > size) {
av_log(avctx, AV_LOG_ERROR, "bitstream written beyond buffer size\n"); av_log(avctx, AV_LOG_ERROR,
return -1; "bitstream written beyond buffer size\n");
} return -1;
memset(pbs[j].buf + pos, 0xff, size - pos); }
memset(pbs[j].buf + pos, 0xff, size - pos);
} }
return 0; return 0;
} }
static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c, static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c,
uint8_t* buf) uint8_t *buf)
{ {
/* /*
* Here's what SMPTE314M says about these two: * Here's what SMPTE314M says about these two:
@ -545,62 +570,66 @@ static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c,
* 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 == AV_PIX_FMT_YUV420P ? 0 : 1); int apt = (c->sys->pix_fmt == AV_PIX_FMT_YUV420P ? 0 : 1);
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 */
c->sys->video_stype; /* signal type video compression */ c->sys->video_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;
} }
return 5; return 5;
} }
static inline int dv_write_dif_id(enum dv_section_type t, uint8_t chan_num, 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 seq_num, uint8_t dif_num,
uint8_t* buf) 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 */
@ -608,19 +637,16 @@ static inline int dv_write_dif_id(enum dv_section_type t, uint8_t chan_num,
return 3; return 3;
} }
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 */
@ -631,7 +657,7 @@ static inline int dv_write_ssyb_id(uint8_t syb_num, uint8_t fr, uint8_t* buf)
return 3; return 3;
} }
static void dv_format_frame(DVVideoContext* c, uint8_t* buf) static void dv_format_frame(DVVideoContext *c, uint8_t *buf)
{ {
int chan, i, j, k; int chan, i, j, k;
@ -641,14 +667,15 @@ static void dv_format_frame(DVVideoContext* c, uint8_t* buf)
/* DV header: 1DIF */ /* DV header: 1DIF */
buf += dv_write_dif_id(dv_sect_header, chan, i, 0, buf); buf += dv_write_dif_id(dv_sect_header, chan, i, 0, buf);
buf += dv_write_pack((c->sys->dsf ? dv_header625 : dv_header525), c, buf); buf += dv_write_pack((c->sys->dsf ? dv_header625 : dv_header525),
c, buf);
buf += 72; /* unused bytes */ buf += 72; /* unused bytes */
/* DV subcode: 2DIFs */ /* DV subcode: 2DIFs */
for (j = 0; j < 2; j++) { for (j = 0; j < 2; j++) {
buf += dv_write_dif_id(dv_sect_subcode, chan, i, j, buf); buf += dv_write_dif_id(dv_sect_subcode, chan, i, j, buf);
for (k = 0; k < 6; k++) for (k = 0; k < 6; k++)
buf += dv_write_ssyb_id(k, (i < c->sys->difseg_size/2), buf) + 5; buf += dv_write_ssyb_id(k, (i < c->sys->difseg_size / 2), buf) + 5;
buf += 29; /* unused bytes */ buf += 29; /* unused bytes */
} }
@ -657,30 +684,29 @@ static void dv_format_frame(DVVideoContext* c, uint8_t* buf)
buf += dv_write_dif_id(dv_sect_vaux, chan, i, j, buf); buf += dv_write_dif_id(dv_sect_vaux, chan, i, j, buf);
buf += dv_write_pack(dv_video_source, c, buf); buf += dv_write_pack(dv_video_source, c, buf);
buf += dv_write_pack(dv_video_control, c, buf); buf += dv_write_pack(dv_video_control, c, buf);
buf += 7*5; buf += 7 * 5;
buf += dv_write_pack(dv_video_source, c, buf); buf += dv_write_pack(dv_video_source, c, buf);
buf += dv_write_pack(dv_video_control, c, buf); buf += dv_write_pack(dv_video_control, c, buf);
buf += 4*5 + 2; /* unused bytes */ buf += 4 * 5 + 2; /* unused bytes */
} }
/* DV Audio/Video: 135 Video DIFs + 9 Audio DIFs */ /* DV Audio/Video: 135 Video DIFs + 9 Audio DIFs */
for (j = 0; j < 135; j++) { for (j = 0; j < 135; j++) {
if (j%15 == 0) { if (j % 15 == 0) {
memset(buf, 0xff, 80); memset(buf, 0xff, 80);
buf += dv_write_dif_id(dv_sect_audio, chan, i, j/15, buf); buf += dv_write_dif_id(dv_sect_audio, chan, i, j / 15, buf);
buf += 77; /* audio control & shuffled PCM audio */ buf += 77; /* audio control & shuffled PCM audio */
} }
buf += dv_write_dif_id(dv_sect_video, chan, i, j, buf); buf += dv_write_dif_id(dv_sect_video, chan, i, j, buf);
buf += 77; /* 1 video macroblock: 1 bytes control buf += 77; /* 1 video macroblock: 1 bytes control
4 * 14 bytes Y 8x8 data * 4 * 14 bytes Y 8x8 data
10 bytes Cr 8x8 data * 10 bytes Cr 8x8 data
10 bytes Cb 8x8 data */ * 10 bytes Cb 8x8 data */
} }
} }
} }
} }
static int dvvideo_encode_frame(AVCodecContext *c, AVPacket *pkt, static int dvvideo_encode_frame(AVCodecContext *c, AVPacket *pkt,
const AVFrame *frame, int *got_packet) const AVFrame *frame, int *got_packet)
{ {
@ -728,6 +754,7 @@ AVCodec ff_dvvideo_encoder = {
.close = dvvideo_encode_close, .close = dvvideo_encode_close,
.capabilities = CODEC_CAP_SLICE_THREADS, .capabilities = CODEC_CAP_SLICE_THREADS,
.pix_fmts = (const enum AVPixelFormat[]) { .pix_fmts = (const enum AVPixelFormat[]) {
AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV422P,
AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE
}, },
}; };

Write Preview
Loading…
Cancel
Save