25 #define CACHED_BITSTREAM_READER !ARCH_X86_32 68 unsigned int slices_size[4];
76 VLC *vlc,
int nb_elems,
void *logctx)
80 for (
int i = 31;
i > 0;
i--)
81 codes_pos[
i] += codes_pos[
i + 1];
83 for (
unsigned i = nb_elems;
i-- > 0;)
88 &he[0].len,
sizeof(he[0]),
89 &he[0].sym,
sizeof(he[0]),
sizeof(he[0].sym),
94 const uint16_t *
diff, intptr_t
w,
95 int *
left,
int *left_top,
int max)
103 for (i = 0; i <
w; i++) {
104 l =
mid_pred(l, src1[i], (l + src1[i] - lt)) + diff[
i];
120 const int max = s->
max - 1;
126 for (i = 0; i < s->
planes; i++) {
127 int left, lefttop, top;
131 ptrdiff_t fake_stride = (p->
linesize[
i] / 2) * (1 + interlaced);
143 dst = (uint16_t *)p->
data[i] + j * sheight * stride;
147 for (k = 0; k <
height; k++) {
148 for (x = 0; x <
width; x++)
154 for (k = 0; k <
height; k++) {
155 for (x = 0; x <
width; x++) {
172 dst = (uint16_t *)p->
data[i] + j * sheight * stride;
179 for (k = 1 + interlaced; k <
height; k++) {
185 dst = (uint16_t *)p->
data[i] + j * sheight * stride;
192 for (k = 1 + interlaced; k <
height; k++) {
193 top = dst[-fake_stride];
196 for (x = 1; x <
width; x++) {
197 top = dst[x - fake_stride];
198 lefttop = dst[x - (fake_stride + 1)];
199 left += top - lefttop + dst[x];
206 dst = (uint16_t *)p->
data[i] + j * sheight * stride;
213 lefttop = left = dst[0];
214 for (k = 1 + interlaced; k <
height; k++) {
216 lefttop = left = dst[0];
233 for (k = 0; k <
width; k++) {
234 b[k] = (b[k] +
g[k]) & max;
235 r[k] = (r[k] +
g[k]) & max;
252 int i, k, x, min_width;
256 for (i = 0; i < s->
planes; i++) {
257 int left, lefttop, top;
266 flags = bytestream_get_byte(&slice);
267 pred = bytestream_get_byte(&slice);
271 if (s->
slices[i][j].
size - 2 < width * height)
273 for (k = 0; k <
height; k++) {
283 for (k = 0; k <
height; k++) {
284 for (x = 0; x <
width; x++) {
308 for (k = 1 + interlaced; k <
height; k++) {
321 min_width =
FFMIN(width, 32);
322 for (k = 1 + interlaced; k <
height; k++) {
323 top = dst[-fake_stride];
326 for (x = 1; x < min_width; x++) {
327 top = dst[x - fake_stride];
328 lefttop = dst[x - (fake_stride + 1)];
329 left += top - lefttop + dst[x];
345 lefttop = left = dst[0];
346 for (k = 1 + interlaced; k <
height; k++) {
348 dst, width, &left, &lefttop);
349 lefttop = left = dst[0];
365 for (i = 0; i <
height; i++) {
378 int table_size,
int max)
383 uint16_t length_count[33] = { 0 };
389 int b = bytestream2_peek_byteu(&gb) & 0x80;
390 int x = bytestream2_get_byteu(&gb) & ~0x80;
396 l += bytestream2_get_byteu(&gb);
399 if (k > max || x == 0 || x > 32) {
404 length_count[x] += l;
418 memset(length_count, 0,
sizeof(length_count));
437 uint32_t first_offset,
offset, next_offset, header_size, slice_width;
441 if (avpkt->
size < 36)
445 if (bytestream2_get_le32u(&gb) !=
MKTAG(
'M',
'A',
'G',
'Y'))
448 header_size = bytestream2_get_le32u(&gb);
449 if (header_size < 32 || header_size >= avpkt->
size) {
451 "header or packet too small %"PRIu32
"\n", header_size);
455 version = bytestream2_get_byteu(&gb);
468 format = bytestream2_get_byteu(&gb);
551 s->
flags = bytestream2_get_byteu(&gb);
555 width = bytestream2_get_le32u(&gb);
556 height = bytestream2_get_le32u(&gb);
561 slice_width = bytestream2_get_le32u(&gb);
578 "invalid number of slices: %d\n", s->
nb_slices);
595 for (i = 0; i < s->
planes; i++) {
600 offset = bytestream2_get_le32u(&gb);
601 if (offset >= avpkt->
size - header_size)
610 next_offset = bytestream2_get_le32u(&gb);
611 if (next_offset <= offset || next_offset >= avpkt->
size - header_size)
617 offset = next_offset;
627 if (bytestream2_get_byteu(&gb) != s->
planes)
also ITU-R BT1361 / IEC 61966-2-4 xvYCC709 / SMPTE RP177 Annex B
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
int(* add_left_pred)(uint8_t *dst, const uint8_t *src, ptrdiff_t w, int left)
This structure describes decoded (raw) audio or video data.
ptrdiff_t const GLvoid * data
int coded_width
Bitstream width / height, may be different from width/height e.g.
#define AV_PIX_FMT_GBRAP10
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
int av_pix_fmt_count_planes(enum AVPixelFormat pix_fmt)
int ff_set_dimensions(AVCodecContext *s, int width, int height)
Check that the provided frame dimensions are valid and set them on the codec context.
static av_cold int init(AVCodecContext *avctx)
also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM / IEC 61966-2-4 xvYCC601 ...
#define avpriv_request_sample(...)
#define AV_PIX_FMT_GBRP10
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
#define FF_ARRAY_ELEMS(a)
unsigned int slices_size[4]
static int build_huffman(AVCodecContext *avctx, const uint8_t *table, int table_size, int max)
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample format(the sample packing is implied by the sample format) and sample rate.The lists are not just lists
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
#define AV_PIX_FMT_GRAY10
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Multithreading support functions.
void(* add_median_pred)(uint8_t *dst, const uint8_t *top, const uint8_t *diff, ptrdiff_t w, int *left, int *left_top)
static av_always_inline void bytestream2_skipu(GetByteContext *g, unsigned int size)
bitstream reader API header.
static const uint16_t table[]
void(* add_gradient_pred)(uint8_t *src, const ptrdiff_t stride, const ptrdiff_t width)
static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)
static int magy_decode_slice(AVCodecContext *avctx, void *tdata, int j, int threadnr)
static int get_bits_left(GetBitContext *gb)
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
enum AVColorRange color_range
MPEG vs JPEG YUV range.
enum AVColorSpace colorspace
YUV colorspace type.
#define AV_PIX_FMT_GBRAP12
const char * name
Name of the codec implementation.
#define AV_PIX_FMT_YUV444P10
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before as well as code calling up to before the decode process starts Call have so the codec calls ff_thread_report set FF_CODEC_CAP_ALLOCATE_PROGRESS in AVCodec caps_internal and use ff_thread_get_buffer() to allocate frames.The frames must then be freed with ff_thread_release_buffer().Otherwise decode directly into the user-supplied frames.Call ff_thread_report_progress() after some part of the current picture has decoded.A good place to put this is where draw_horiz_band() is called-add this if it isn't called anywhere
void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size)
Allocate a buffer, reusing the given one if large enough.
enum AVPictureType pict_type
Picture type of the frame.
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE(*table)[2], int bits, int max_depth)
Parse a vlc code.
static av_always_inline unsigned int bytestream_get_buffer(const uint8_t **b, uint8_t *dst, unsigned int size)
static const float pred[4]
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
static av_cold int magy_decode_init(AVCodecContext *avctx)
static av_always_inline int bytestream2_tell(GetByteContext *g)
int(* execute2)(struct AVCodecContext *c, int(*func)(struct AVCodecContext *c2, void *arg, int jobnr, int threadnr), void *arg2, int *ret, int count)
The codec may call this to execute several independent things.
static int huff_build(const uint8_t len[], uint16_t codes_pos[33], VLC *vlc, int nb_elems, void *logctx)
int(* add_left_pred_int16)(uint16_t *dst, const uint16_t *src, unsigned mask, ptrdiff_t w, unsigned left)
Libavcodec external API header.
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
main external API structure.
static int magy_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2]...the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so...,+,-,+,-,+,+,-,+,-,+,...hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32-hcoeff[1]-hcoeff[2]-...a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2}an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||.........intra?||||:Block01:yes no||||:Block02:.................||||:Block03::y DC::ref index:||||:Block04::cb DC::motion x:||||.........:cr DC::motion y:||||.................|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------------------------------|||Y subbands||Cb subbands||Cr subbands||||------||------||------|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||------||------||------||||------||------||------|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||------||------||------||||------||------||------|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||------||------||------||||------||------||------|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------------------------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction------------|\Dequantization-------------------\||Reference frames|\IDWT|--------------|Motion\|||Frame 0||Frame 1||Compensation.OBMC v-------|--------------|--------------.\------> Frame n output Frame Frame<----------------------------------/|...|-------------------Range Coder:============Binary Range Coder:-------------------The implemented range coder is an adapted version based upon"Range encoding: an algorithm for removing redundancy from a digitised message."by G.N.N.Martin.The symbols encoded by the Snow range coder are bits(0|1).The associated probabilities are not fix but change depending on the symbol mix seen so far.bit seen|new state---------+-----------------------------------------------0|256-state_transition_table[256-old_state];1|state_transition_table[old_state];state_transition_table={0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:-------------------------FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1.the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled left
void ff_llviddsp_init(LLVidDSPContext *c)
#define AV_PIX_FMT_YUV420P10
AVCodec ff_magicyuv_decoder
int ff_init_vlc_from_lengths(VLC *vlc_arg, int nb_bits, int nb_codes, const int8_t *lens, int lens_wrap, const void *symbols, int symbols_wrap, int symbols_size, int offset, int flags, void *logctx)
Build VLC decoding tables suitable for use with get_vlc2()
static int magy_decode_slice10(AVCodecContext *avctx, void *tdata, int j, int threadnr)
#define AV_PIX_FMT_GBRP12
int(* magy_decode_slice)(AVCodecContext *avctx, void *tdata, int j, int threadnr)
#define flags(name, subs,...)
#define AV_PIX_FMT_YUV422P10
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Narrow or limited range content.
static av_cold int magy_decode_end(AVCodecContext *avctx)
GLint GLenum GLboolean GLsizei stride
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
common internal api header.
planar GBRA 4:4:4:4 32bpp
static av_always_inline int diff(const uint32_t a, const uint32_t b)
VLC_TYPE(* table)[2]
code, bits
int key_frame
1 -> keyframe, 0-> not
static void magicyuv_median_pred16(uint16_t *dst, const uint16_t *src1, const uint16_t *diff, intptr_t w, int *left, int *left_top, int max)
#define FFSWAP(type, a, b)
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
void(* add_bytes)(uint8_t *dst, uint8_t *src, ptrdiff_t w)
#define MKTAG(a, b, c, d)
This structure stores compressed data.
void ff_free_vlc(VLC *vlc)
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
#define AV_CEIL_RSHIFT(a, b)