73 if (partial_bit_count > 0) {
75 re_index -= partial_bit_count;
95 if (re_index + vlc_len > last_index) {
99 re_index = last_index;
110 block[scan_table[pos]] =
level;
135 int quant, dc, dct_mode, class1, j;
136 int mb_index, mb_x, mb_y, last_index;
137 int y_stride, linesize;
148 const int log2_blocksize = 3;
149 int is_field_mode[5];
151 assert((((
int)mb_bit_buffer) & 7) == 0);
152 assert((((
int)vs_bit_buffer) & 7) == 0);
154 memset(sblock, 0, 5*
DV_MAX_BPM*
sizeof(*sblock));
158 block1 = &sblock[0][0];
161 for (mb_index = 0; mb_index < 5; mb_index++, mb1 += s->
sys->
bpm, block1 += s->
sys->
bpm * 64) {
163 quant = buf_ptr[3] & 0x0f;
168 is_field_mode[mb_index] = 0;
169 for (j = 0; j < s->
sys->
bpm; j++) {
181 is_field_mode[mb_index] |= !j && dct_mode;
193 buf_ptr += last_index >> 3;
197 av_dlog(avctx,
"MB block: %d, %d ", mb_index, j);
216 for (j = 0; j < s->
sys->
bpm; j++, block += 64, mb++) {
232 block = &sblock[0][0];
237 for (mb_index = 0; mb_index < 5; mb_index++) {
238 for (j = 0; j < s->
sys->
bpm; j++) {
240 av_dlog(avctx,
"start %d:%d\n", mb_index, j);
243 if (mb->
pos >= 64 && mb->
pos < 127)
251 block = &sblock[0][0];
253 for (mb_index = 0; mb_index < 5; mb_index++) {
259 (s->
sys->
height >= 720 && mb_y != 134)) {
260 y_stride = (s->
picture.
linesize[0] << ((!is_field_mode[mb_index]) * log2_blocksize));
262 y_stride = (2 << log2_blocksize);
266 mb[0] .
idct_put(y_ptr , linesize, block + 0*64);
268 mb[2].
idct_put(y_ptr + (1 << log2_blocksize) , linesize, block + 2*64);
270 mb[1].
idct_put(y_ptr + (1 << log2_blocksize) , linesize, block + 1*64);
271 mb[2].
idct_put(y_ptr + y_stride, linesize, block + 2*64);
272 mb[3].
idct_put(y_ptr + (1 << log2_blocksize) + y_stride, linesize, block + 3*64);
280 for (j = 2; j; j--) {
283 uint64_t aligned_pixels[64/8];
288 for (y = 0; y < (1 << log2_blocksize); y++, c_ptr += s->
picture.
linesize[j], pixels += 8) {
289 ptr1 = pixels + (1 << (log2_blocksize - 1));
291 for (x = 0; x < (1 << (log2_blocksize - 1)); x++) {
292 c_ptr[x] = pixels[x];
298 y_stride = (mb_y == 134) ? (1 << log2_blocksize) :
299 s->
picture.
linesize[j] << ((!is_field_mode[mb_index]) * log2_blocksize);
301 (mb++)->
idct_put(c_ptr , linesize, block); block += 64;
303 (mb++)->
idct_put(c_ptr + y_stride, linesize, block); block += 64;
314 void *
data,
int *got_frame,
318 int buf_size = avpkt->
size;
356 vsc_pack = buf + 80*5 + 48 + 5;
359 is16_9 = (vsc_pack && ((vsc_pack[2] & 0x07) == 0x02 || (!apt && (vsc_pack[2] & 0x07) == 0x07)));
static void av_unused put_bits32(PutBitContext *s, uint32_t value)
Write exactly 32 bits into a bitstream.
This structure describes decoded (raw) audio or video data.
struct BlockInfo BlockInfo
RL_VLC_ELEM ff_dv_rl_vlc[1184]
void(* release_buffer)(struct AVCodecContext *c, AVFrame *pic)
Called to release buffers which were allocated with get_buffer.
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
int ff_dv_init_dynamic_tables(const DVprofile *d)
void avcodec_set_dimensions(AVCodecContext *s, int width, int height)
struct DVVideoContext DVVideoContext
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel...
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
static void dv_calculate_mb_xy(DVVideoContext *s, DVwork_chunk *work_chunk, int m, int *mb_x, int *mb_y)
static int dvvideo_close(AVCodecContext *c)
av_dlog(ac->avr,"%d samples - audio_convert: %s to %s (%s)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt), use_generic?ac->func_descr_generic:ac->func_descr)
const uint8_t ff_dv_quant_offset[4]
static int get_sbits(GetBitContext *s, int n)
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
static int decode(MimicContext *ctx, int quality, int num_coeffs, int is_iframe)
enum AVPixelFormat pix_fmt
bitstream reader API header.
int interlaced_frame
The content of the picture is interlaced.
#define LOCAL_ALIGNED_16(t, v,...)
const uint8_t * block_sizes
static int init(AVCodecParserContext *s)
static int dv_work_pool_size(const DVprofile *d)
static int get_bits_left(GetBitContext *gb)
#define UPDATE_CACHE(name, gb)
static void bit_copy(PutBitContext *pb, GetBitContext *gb)
int reference
is this picture used as reference The values for this are the same as the MpegEncContext.picture_structure variable, that is 1->top field, 2->bottom field, 3->frame/both fields.
void(* idct_put[2])(uint8_t *dest, int line_size, DCTELEM *block)
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
#define DV_PROFILE_IS_HD(p)
AVCodec ff_dvvideo_decoder
static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, DCTELEM *block)
void av_log(void *avcl, int level, const char *fmt,...)
const char * name
Name of the codec implementation.
static void put_bits(PutBitContext *s, int n, unsigned int value)
Write up to 31 bits into a bitstream.
#define CLOSE_READER(name, gb)
static int put_bits_count(PutBitContext *s)
enum AVPictureType pict_type
Picture type of the frame, see ?_TYPE below.
static DCTELEM block1[64]
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame)
Get a buffer for a frame.
uint32_t partial_bit_buffer
const uint8_t * scan_table
#define SHOW_UBITS(name, gb, num)
static void idct_put(FourXContext *f, int x, int y)
static int dvvideo_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
const uint32_t * factor_table
static int dv_decode_video_segment(AVCodecContext *avctx, void *arg)
int linesize[AV_NUM_DATA_POINTERS]
Size, in bytes, of the data for each picture/channel plane.
main external API structure.
static void(WINAPI *cond_broadcast)(pthread_cond_t *cond)
static void close(AVCodecParserContext *s)
#define OPEN_READER(name, gb)
static unsigned int get_bits1(GetBitContext *s)
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
#define FF_INPUT_BUFFER_PADDING_SIZE
av_cold int ff_dvvideo_init(AVCodecContext *avctx)
uint8_t partial_bit_count
#define DV_MAX_BPM
maximum number of blocks per macroblock in any DV format
#define CODEC_CAP_SLICE_THREADS
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
common internal api header.
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
int(* execute)(struct AVCodecContext *c, int(*func)(struct AVCodecContext *c2, void *arg), void *arg2, int *ret, int count, int size)
The codec may call this to execute several independent things.
int top_field_first
If the content is interlaced, is top field displayed first.
const DVprofile * avpriv_dv_frame_profile(const DVprofile *sys, const uint8_t *frame, unsigned buf_size)
int key_frame
1 -> keyframe, 0-> not
DVwork_chunk * work_chunks
This structure stores compressed data.
void(* idct_put)(uint8_t *dest, int line_size, DCTELEM *block)
static const int dv_iweight_bits
if(!(ptr_align%ac->ptr_align)&&samples_align >=aligned_len)