32 #define CACHED_BITSTREAM_READER !ARCH_X86_32 84 ptr = picture->
data[0];
85 ptr1 = picture->
data[1];
86 ptr2 = picture->
data[2];
90 for (
int y = 0; y <
height; y += 2) {
92 for (
int x = 0; x < width - 1; x++) {
93 fill = bytestream2_get_byte(gb);
95 *(dst++) = (fill + bytestream2_peek_byte(gb) + 1) >> 1;
97 fill = bytestream2_get_byte(gb);
104 for (
int x = 0; x < width - 1; x++) {
105 fill = bytestream2_get_byte(gb);
107 *(dst++) = (fill + bytestream2_peek_byte(gb) + 1) >> 1;
109 fill = bytestream2_get_byte(gb);
116 for (
int x = 0; x < (width >> 1) - 1; x++) {
117 fill = bytestream2_get_byte(gb);
119 *(dst++) = (fill + bytestream2_peek_byte(gb) + 1) >> 1;
121 fill = bytestream2_get_byte(gb);
128 for (
int x = 0; x < (width >> 1) - 1; x++) {
129 fill = bytestream2_get_byte(gb);
131 *(dst++) = (fill + bytestream2_peek_byte(gb) + 1) >> 1;
133 fill = bytestream2_get_byte(gb);
150 for (
int y = 0; y < height - 2; y += 2) {
153 const uint8_t *src2 = dst + linesize;
154 for (x = 0; x < width - 2; x += 2) {
155 dst[x] = (src1[x] + src2[x] + 1) >> 1;
156 dst[x + 1] = (src1[x] + src2[x] + src1[x + 2] + src2[x + 2] + 2) >> 2;
158 dst[x] = dst[x + 1] = (src1[x] + src2[x] + 1) >> 1;
160 ptr += linesize << 1;
164 dst = ptr + linesize;
165 for (x = 0; x < width - 2; x += 2) {
167 dst[x + 1] = (src1[x] + src1[x + 2] + 1) >> 1;
169 dst[x] = dst[x + 1] = src1[x];
175 for (
int y = height - 2; y >= 0; y -= 2) {
176 const uint8_t *
src = ptr + (y >> 1) * linesize;
177 uint8_t *dst = ptr + y * linesize;
179 dst[width - 2] = dst[width - 1] = src[(width >> 1) - 1];
180 for (
int x = width - 4; x >= 0; x -= 2) {
181 dst[x] = src[x >> 1];
182 dst[x + 1] = (src[x >> 1] + src[(x >> 1) + 1] + 1) >> 1;
196 count = bytestream2_get_byte(gb) + 1;
200 for (
int j = 0; j <
count; j++) {
201 const int bit = bytestream2_get_byteu(gb) + 1;
202 const int code = bytestream2_get_be16u(gb);
203 const int sym = bytestream2_get_byteu(gb);
225 int target_res,
int curr_res)
233 const int scaling = target_res - curr_res;
234 const uint8_t type2idx[] = { 0, 0xff, 1, 2 };
241 height = img_info[curr_res].
height;
254 while (shiftreg != 0xfffffe) {
269 idx = type2idx[
type];
271 data = frame->
data[idx] + (y >> !!idx) * frame->
linesize[idx];
273 x2 = avctx->
width >> (scaling + !!idx);
274 for (
int x = 0; x < x2; x++) {
307 if (!memcmp(
"PCD_OPA", buf, 7)) {
310 "reading first thumbnail only\n");
311 }
else if (avpkt->
size < 786432) {
313 }
else if (memcmp(
"PCD_IPI", buf + 0x800, 7)) {
321 else if (avpkt->
size <= 788480)
348 for (
int y = 0; y < avctx->
height; y += 2) {
382 for (
int n = 0; n < 3; n++) {
394 for (
int n = 0; n < 3; n++) {
408 for (
int y = 0; y < avctx->
height >> 1; y++) {
409 for (
int x = 0; x < avctx->
width >> 1; x++) {
439 for (
int i = 0;
i < 3;
i++)
445 #define OFFSET(x) offsetof(PhotoCDContext, x) 446 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM 449 {
"lowres",
"Lower the decoding resolution by a power of two",
466 .priv_class = &photocd_class,
also ITU-R BT1361 / IEC 61966-2-4 xvYCC709 / SMPTE RP177 Annex B
static av_cold int photocd_decode_close(AVCodecContext *avctx)
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
This structure describes decoded (raw) audio or video data.
ptrdiff_t const GLvoid * data
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
#define AV_LOG_WARNING
Something somehow does not look correct.
#define LIBAVUTIL_VERSION_INT
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)
enum AVColorRange color_range
MPEG vs JPEG YUV range.
int ff_init_vlc_sparse(VLC *vlc_arg, int nb_bits, int nb_codes, const void *bits, int bits_wrap, int bits_size, const void *codes, int codes_wrap, int codes_size, const void *symbols, int symbols_wrap, int symbols_size, int flags)
const char * av_default_item_name(void *ptr)
Return the context name.
AVCodec ff_photocd_decoder
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)
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_RL16
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
static av_noinline int decode_huff(AVCodecContext *avctx, AVFrame *frame, int target_res, int curr_res)
Multithreading support functions.
static av_noinline void interp_lines(uint8_t *ptr, int linesize, int width, int height)
static int get_bits_count(const GetBitContext *s)
static av_noinline int read_hufftable(AVCodecContext *avctx, VLC *vlc)
bitstream reader API header.
static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)
static int get_bits_left(GetBitContext *gb)
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
static av_always_inline unsigned int bytestream2_get_buffer(GetByteContext *g, uint8_t *dst, unsigned int size)
also ITU-R BT1361 / IEC 61966-2-4 / SMPTE RP177 Annex B
simple assert() macros that are a bit more flexible than ISO C assert().
const char * name
Name of the codec implementation.
static av_noinline void interp_pixels(uint8_t *ptr, int linesize, int width, int height)
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
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
enum AVPictureType pict_type
Picture type of the frame.
int width
picture width / height.
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
static const AVClass photocd_class
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 int photocd_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
static av_always_inline int bytestream2_tell(GetByteContext *g)
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.
main external API structure.
static av_noinline void interp_lowres(PhotoCDContext *s, AVFrame *picture, int width, int height)
static const ImageInfo img_info[6]
Describe the class of an AVClass context structure.
static void skip_bits(GetBitContext *s, int n)
enum AVColorSpace colorspace
YUV colorspace type.
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
static const AVOption options[]
static av_const int sign_extend(int val, unsigned bits)
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
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)
IEC 61966-2-1 (sRGB or sYCC)
common internal api header.
#define bit(string, value)
VLC_TYPE(* table)[2]
code, bits
static av_cold int photocd_decode_init(AVCodecContext *avctx)
int key_frame
1 -> keyframe, 0-> not
static av_always_inline int bytestream2_seek(GetByteContext *g, int offset, int whence)
This structure stores compressed data.
void ff_free_vlc(VLC *vlc)
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators...