Quelle  delta.h   Sprache: C

/* SPDX-License-Identifier: GPL-2.0 */
/*
 * Copyright (C) STMicroelectronics SA 2015
 * Author: Hugues Fruchet <hugues.fruchet@st.com> for STMicroelectronics.
 */

#ifndef DELTA_H
#define DELTA_H

#include <linux/rpmsg.h>
#include <media/v4l2-device.h>
#include <media/v4l2-mem2mem.h>

#include "delta-cfg.h"

/*
 * enum delta_state - state of decoding instance
 *
 *@DELTA_STATE_WF_FORMAT:
 * Wait for compressed format to be set by V4L2 client in order
 * to know what is the relevant decoder to open.
 *
 *@DELTA_STATE_WF_STREAMINFO:
 * Wait for stream information to be available (bitstream
 * header parsing is done).
 *
 *@DELTA_STATE_READY:
 * Decoding instance is ready to decode compressed access unit.
 *
 *@DELTA_STATE_WF_EOS:
 * Decoding instance is waiting for EOS (End Of Stream) completion.
 *
 *@DELTA_STATE_EOS:
 * EOS (End Of Stream) is completed (signaled to user). Decoding instance
 * should then be closed.
 */
enum delta_state {
 DELTA_STATE_WF_FORMAT,
 DELTA_STATE_WF_STREAMINFO,
 DELTA_STATE_READY,
 DELTA_STATE_WF_EOS,
 DELTA_STATE_EOS
};

/*
 * struct delta_streaminfo - information about stream to decode
 *
 * @flags: validity of fields (crop, pixelaspect, other)
 * @width: width of video stream
 * @height: height ""
 * @streamformat: fourcc compressed format of video (MJPEG, MPEG2, ...)
 * @dpb: number of frames needed to decode a single frame
 * (h264 dpb, up to 16)
 * @crop: cropping window inside decoded frame (1920x1080@0,0
 * inside 1920x1088 frame for ex.)
 * @pixelaspect: pixel aspect ratio of video (4/3, 5/4)
 * @field: interlaced or not
 * @profile: profile string
 * @level: level string
 * @other: other string information from codec
 * @colorspace: colorspace identifier
 * @xfer_func: transfer function identifier
 * @ycbcr_enc: Y'CbCr encoding identifier
 * @quantization: quantization identifier
 */
struct delta_streaminfo {
 u32 flags;
 u32 streamformat;
 u32 width;
 u32 height;
 u32 dpb;
 struct v4l2_rect crop;
 struct v4l2_fract pixelaspect;
 enum v4l2_field field;
 u8 profile[32];
 u8 level[32];
 u8 other[32];
 enum v4l2_colorspace colorspace;
 enum v4l2_xfer_func xfer_func;
 enum v4l2_ycbcr_encoding ycbcr_enc;
 enum v4l2_quantization quantization;
};

#define DELTA_STREAMINFO_FLAG_CROP  0x0001
#define DELTA_STREAMINFO_FLAG_PIXELASPECT 0x0002
#define DELTA_STREAMINFO_FLAG_OTHER  0x0004

/*
 * struct delta_au - access unit structure.
 *
 * @vbuf: video buffer information for V4L2
 * @list: V4L2 m2m list that the frame belongs to
 * @prepared: if set vaddr/paddr are resolved
 * @vaddr: virtual address (kernel can read/write)
 * @paddr: physical address (for hardware)
 * @flags: access unit type (V4L2_BUF_FLAG_KEYFRAME/PFRAME/BFRAME)
 * @dts: decoding timestamp of this access unit
 */
struct delta_au {
 struct vb2_v4l2_buffer vbuf; /* keep first */
 struct list_head list; /* keep second */

 bool prepared;
 u32 size;
 void *vaddr;
 dma_addr_t paddr;
 u32 flags;
 u64 dts;
};

/*
 * struct delta_frameinfo - information about decoded frame
 *
 * @flags: validity of fields (crop, pixelaspect)
 * @pixelformat: fourcc code for uncompressed video format
 * @width: width of frame
 * @height: height of frame
 * @aligned_width: width of frame (with encoder or decoder alignment
 * constraint)
 * @aligned_height: height of frame (with encoder or decoder alignment
 * constraint)
 * @size: maximum size in bytes required for data
 * @crop: cropping window inside frame (1920x1080@0,0
 * inside 1920x1088 frame for ex.)
 * @pixelaspect: pixel aspect ratio of video (4/3, 5/4)
 * @field: interlaced mode
 * @colorspace: colorspace identifier
 * @xfer_func: transfer function identifier
 * @ycbcr_enc: Y'CbCr encoding identifier
 * @quantization: quantization identifier
 */
struct delta_frameinfo {
 u32 flags;
 u32 pixelformat;
 u32 width;
 u32 height;
 u32 aligned_width;
 u32 aligned_height;
 u32 size;
 struct v4l2_rect crop;
 struct v4l2_fract pixelaspect;
 enum v4l2_field field;
 enum v4l2_colorspace colorspace;
 enum v4l2_xfer_func xfer_func;
 enum v4l2_ycbcr_encoding ycbcr_enc;
 enum v4l2_quantization quantization;
};

#define DELTA_FRAMEINFO_FLAG_CROP  0x0001
#define DELTA_FRAMEINFO_FLAG_PIXELASPECT 0x0002

/*
 * struct delta_frame - frame structure.
 *
 * @vbuf: video buffer information for V4L2
 * @list: V4L2 m2m list that the frame belongs to
 * @info: frame information (width, height, format, alignment...)
 * @prepared: if set pix/vaddr/paddr are resolved
 * @index: frame index, aligned on V4L2 wow
 * @vaddr: virtual address (kernel can read/write)
 * @paddr: physical address (for hardware)
 * @state: frame state for frame lifecycle tracking
 * (DELTA_FRAME_FREE/DEC/OUT/REC/...)
 * @flags: frame type (V4L2_BUF_FLAG_KEYFRAME/PFRAME/BFRAME)
 * @dts: decoding timestamp of this frame
 * @field: field order for interlaced frame
 */
struct delta_frame {
 struct vb2_v4l2_buffer vbuf; /* keep first */
 struct list_head list; /* keep second */

 struct delta_frameinfo info;
 bool prepared;
 u32 index;
 void *vaddr;
 dma_addr_t paddr;
 u32 state;
 u32 flags;
 u64 dts;
 enum v4l2_field field;
};

/* frame state for frame lifecycle tracking */
#define DELTA_FRAME_FREE 0x00 /* is free and can be used for decoding */
#define DELTA_FRAME_REF  0x01 /* is a reference frame */
#define DELTA_FRAME_BSY  0x02 /* is owned by decoder and busy */
#define DELTA_FRAME_DEC  0x04 /* contains decoded content */
#define DELTA_FRAME_OUT  0x08 /* has been given to user */
#define DELTA_FRAME_RDY  0x10 /* is ready but still held by decoder */
#define DELTA_FRAME_M2M  0x20 /* is owned by mem2mem framework */

/*
 * struct delta_dts - decoding timestamp.
 *
 * @list: list to chain timestamps
 * @val: timestamp in microseconds
 */
struct delta_dts {
 struct list_head list;
 u64 val;
};

struct delta_buf {
 u32 size;
 void *vaddr;
 dma_addr_t paddr;
 const char *name;
 unsigned long attrs;
};

struct delta_ipc_ctx {
 int cb_err;
 u32 copro_hdl;
 struct completion done;
 struct delta_buf ipc_buf_struct;
 struct delta_buf *ipc_buf;
};

struct delta_ipc_param {
 u32 size;
 void *data;
};

struct delta_ctx;

/*
 * struct delta_dec - decoder structure.
 *
 * @name: name of this decoder
 * @streamformat: input stream format that this decoder support
 * @pixelformat: pixel format of decoded frame that this decoder support
 * @max_width: (optional) maximum width that can decode this decoder
 * if not set, maximum width is DELTA_MAX_WIDTH
 * @max_height: (optional) maximum height that can decode this decoder
 * if not set, maximum height is DELTA_MAX_HEIGHT
 * @pm: (optional) if set, decoder will manage power on its own
 * @open: open this decoder
 * @close: close this decoder
 * @setup_frame: setup frame to be used by decoder, see below
 * @get_streaminfo: get stream related infos, see below
 * @get_frameinfo: get decoded frame related infos, see below
 * @set_frameinfo: (optional) set decoded frame related infos, see below
 * @setup_frame: setup frame to be used by decoder, see below
 * @decode: decode a single access unit, see below
 * @get_frame: get the next decoded frame available, see below
 * @recycle: recycle the given frame, see below
 * @flush: (optional) flush decoder, see below
 * @drain: (optional) drain decoder, see below
 */
struct delta_dec {
 const char *name;
 u32 streamformat;
 u32 pixelformat;
 u32 max_width;
 u32 max_height;
 bool pm;

 /*
 * decoder ops
 */
 int (*open)(struct delta_ctx *ctx);
 int (*close)(struct delta_ctx *ctx);

 /*
 * setup_frame() - setup frame to be used by decoder
 * @ctx: (in) instance
 * @frame: (in) frame to use
 *  @frame.index (in) identifier of frame
 *  @frame.vaddr (in) virtual address (kernel can read/write)
 *  @frame.paddr (in) physical address (for hardware)
 *
 * Frame is to be allocated by caller, then given
 * to decoder through this call.
 * Several frames must be given to decoder (dpb),
 * each frame is identified using its index.
 */
 int (*setup_frame)(struct delta_ctx *ctx, struct delta_frame *frame);

 /*
 * get_streaminfo() - get stream related infos
 * @ctx: (in) instance
 * @streaminfo: (out) width, height, dpb,...
 *
 * Precondition: stream header must have been successfully
 * parsed to have this call successful & @streaminfo valid.
 * Header parsing must be done using decode(), giving
 * explicitly header access unit or first access unit of bitstream.
 * If no valid header is found, get_streaminfo will return -ENODATA,
 * in this case the next bitstream access unit must be decoded till
 * get_streaminfo becomes successful.
 */
 int (*get_streaminfo)(struct delta_ctx *ctx,
         struct delta_streaminfo *streaminfo);

 /*
 * get_frameinfo() - get decoded frame related infos
 * @ctx: (in) instance
 * @frameinfo: (out) width, height, alignment, crop, ...
 *
 * Precondition: get_streaminfo() must be successful
 */
 int (*get_frameinfo)(struct delta_ctx *ctx,
        struct delta_frameinfo *frameinfo);

 /*
 * set_frameinfo() - set decoded frame related infos
 * @ctx: (in) instance
 * @frameinfo: (out) width, height, alignment, crop, ...
 *
 * Optional.
 * Typically used to negotiate with decoder the output
 * frame if decoder can do post-processing.
 */
 int (*set_frameinfo)(struct delta_ctx *ctx,
        struct delta_frameinfo *frameinfo);

 /*
 * decode() - decode a single access unit
 * @ctx: (in) instance
 * @au: (in/out) access unit
 *  @au.size (in) size of au to decode
 *  @au.vaddr (in) virtual address (kernel can read/write)
 *  @au.paddr (in) physical address (for hardware)
 *  @au.flags (out) au type (V4L2_BUF_FLAG_KEYFRAME/
 * PFRAME/BFRAME)
 *
 * Decode the access unit given. Decode is synchronous;
 * access unit memory is no more needed after this call.
 * After this call, none, one or several frames could
 * have been decoded, which can be retrieved using
 * get_frame().
 */
 int (*decode)(struct delta_ctx *ctx, struct delta_au *au);

 /*
 * get_frame() - get the next decoded frame available
 * @ctx: (in) instance
 * @frame: (out) frame with decoded data:
 *  @frame.index (out) identifier of frame
 *  @frame.field (out) field order for interlaced frame
 *  @frame.state (out) frame state for frame lifecycle tracking
 *  @frame.flags (out) frame type (V4L2_BUF_FLAG_KEYFRAME/
 * PFRAME/BFRAME)
 *
 * Get the next available decoded frame.
 * If no frame is available, -ENODATA is returned.
 * If a frame is available, frame structure is filled with
 * relevant data, frame.index identifying this exact frame.
 * When this frame is no more needed by upper layers,
 * recycle() must be called giving this frame identifier.
 */
 int (*get_frame)(struct delta_ctx *ctx, struct delta_frame **frame);

 /*
 * recycle() - recycle the given frame
 * @ctx: (in) instance
 * @frame: (in) frame to recycle:
 *  @frame.index (in) identifier of frame
 *
 * recycle() is to be called by user when the decoded frame
 * is no more needed (composition/display done).
 * This frame will then be reused by decoder to proceed
 * with next frame decoding.
 * If not enough frames have been provided through setup_frame(),
 * or recycle() is not called fast enough, the decoder can run out
 * of available frames to proceed with decoding (starvation).
 * This case is guarded by wq_recycle wait queue which ensures that
 * decoder is called only if at least one frame is available.
 */
 int (*recycle)(struct delta_ctx *ctx, struct delta_frame *frame);

 /*
 * flush() - flush decoder
 * @ctx: (in) instance
 *
 * Optional.
 * Reset decoder context and discard all internal buffers.
 * This allows implementation of seek, which leads to discontinuity
 * of input bitstream that decoder must know to restart its internal
 * decoding logic.
 */
 int (*flush)(struct delta_ctx *ctx);

 /*
 * drain() - drain decoder
 * @ctx: (in) instance
 *
 * Optional.
 * Mark decoder pending frames (decoded but not yet output) as ready
 * so that they can be output to client at EOS (End Of Stream).
 * get_frame() is to be called in a loop right after drain() to
 * get all those pending frames.
 */
 int (*drain)(struct delta_ctx *ctx);
};

struct delta_dev;

/*
 * struct delta_ctx - instance structure.
 *
 * @flags: validity of fields (streaminfo)
 * @fh: V4L2 file handle
 * @dev: device context
 * @dec: selected decoder context for this instance
 * @ipc_ctx: context of IPC communication with firmware
 * @state: instance state
 * @frame_num: frame number
 * @au_num: access unit number
 * @max_au_size: max size of an access unit
 * @streaminfo: stream information (width, height, dpb, interlacing...)
 * @frameinfo: frame information (width, height, format, alignment...)
 * @nb_of_frames: number of frames available for decoding
 * @frames: array of decoding frames to keep track of frame
 * state and manage frame recycling
 * @decoded_frames: nb of decoded frames from opening
 * @output_frames: nb of output frames from opening
 * @dropped_frames: nb of frames dropped (ie access unit not parsed
 * or frame decoded but not output)
 * @stream_errors: nb of stream errors (corrupted, not supported, ...)
 * @decode_errors: nb of decode errors (firmware error)
 * @sys_errors: nb of system errors (memory, ipc, ...)
 * @dts: FIFO of decoding timestamp.
 * output frames are timestamped with incoming access
 * unit timestamps using this fifo.
 * @name: string naming this instance (debug purpose)
 * @run_work: decoding work
 * @lock: lock for decoding work serialization
 * @aborting: true if current job aborted
 * @priv: private decoder context for this instance, allocated
 * by decoder @open time.
 */
struct delta_ctx {
 u32 flags;
 struct v4l2_fh fh;
 struct delta_dev *dev;
 const struct delta_dec *dec;
 struct delta_ipc_ctx ipc_ctx;

 enum delta_state state;
 u32 frame_num;
 u32 au_num;
 size_t max_au_size;
 struct delta_streaminfo streaminfo;
 struct delta_frameinfo frameinfo;
 u32 nb_of_frames;
 struct delta_frame *frames[DELTA_MAX_FRAMES];
 u32 decoded_frames;
 u32 output_frames;
 u32 dropped_frames;
 u32 stream_errors;
 u32 decode_errors;
 u32 sys_errors;
 struct list_head dts;
 char name[100];
 struct work_struct run_work;
 struct mutex lock;
 bool aborting;
 void *priv;
};

#define DELTA_FLAG_STREAMINFO 0x0001
#define DELTA_FLAG_FRAMEINFO 0x0002

#define DELTA_MAX_FORMATS  DELTA_MAX_DECODERS

/*
 * struct delta_dev - device struct, 1 per probe (so single one for
 * all platform life)
 *
 * @v4l2_dev: v4l2 device
 * @vdev: v4l2 video device
 * @pdev: platform device
 * @dev: device
 * @m2m_dev: memory-to-memory V4L2 device
 * @lock: device lock, for crit section & V4L2 ops serialization.
 * @clk_delta: delta main clock
 * @clk_st231: st231 coprocessor main clock
 * @clk_flash_promip: flash promip clock
 * @decoders: list of registered decoders
 * @nb_of_decoders: nb of registered decoders
 * @pixelformats: supported uncompressed video formats
 * @nb_of_pixelformats: number of supported umcompressed video formats
 * @streamformats: supported compressed video formats
 * @nb_of_streamformats:number of supported compressed video formats
 * @instance_id: rolling counter identifying an instance (debug purpose)
 * @work_queue: decoding job work queue
 * @rpmsg_driver: rpmsg IPC driver
 * @rpmsg_device: rpmsg IPC device
 */
struct delta_dev {
 struct v4l2_device v4l2_dev;
 struct video_device *vdev;
 struct platform_device *pdev;
 struct device *dev;
 struct v4l2_m2m_dev *m2m_dev;
 struct mutex lock;
 struct clk *clk_delta;
 struct clk *clk_st231;
 struct clk *clk_flash_promip;
 const struct delta_dec *decoders[DELTA_MAX_DECODERS];
 u32 nb_of_decoders;
 u32 pixelformats[DELTA_MAX_FORMATS];
 u32 nb_of_pixelformats;
 u32 streamformats[DELTA_MAX_FORMATS];
 u32 nb_of_streamformats;
 u8 instance_id;
 struct workqueue_struct *work_queue;
 struct rpmsg_driver rpmsg_driver;
 struct rpmsg_device *rpmsg_device;
};

static inline char *frame_type_str(u32 flags)
{
 if (flags & V4L2_BUF_FLAG_KEYFRAME)
  return "I";
 if (flags & V4L2_BUF_FLAG_PFRAME)
  return "P";
 if (flags & V4L2_BUF_FLAG_BFRAME)
  return "B";
 if (flags & V4L2_BUF_FLAG_LAST)
  return "EOS";
 return "?";
}

static inline char *frame_field_str(enum v4l2_field field)
{
 if (field == V4L2_FIELD_NONE)
  return "-";
 if (field == V4L2_FIELD_TOP)
  return "T";
 if (field == V4L2_FIELD_BOTTOM)
  return "B";
 if (field == V4L2_FIELD_INTERLACED)
  return "I";
 if (field == V4L2_FIELD_INTERLACED_TB)
  return "TB";
 if (field == V4L2_FIELD_INTERLACED_BT)
  return "BT";
 return "?";
}

static inline char *frame_state_str(u32 state, char *str, unsigned int len)
{
 snprintf(str, len, "%s %s %s %s %s %s",
   (state & DELTA_FRAME_REF)  ? "ref" : " ",
   (state & DELTA_FRAME_BSY)  ? "bsy" : " ",
   (state & DELTA_FRAME_DEC)  ? "dec" : " ",
   (state & DELTA_FRAME_OUT)  ? "out" : " ",
   (state & DELTA_FRAME_M2M)  ? "m2m" : " ",
   (state & DELTA_FRAME_RDY)  ? "rdy" : " ");
 return str;
}

int delta_get_frameinfo_default(struct delta_ctx *ctx,
    struct delta_frameinfo *frameinfo);
int delta_recycle_default(struct delta_ctx *pctx,
     struct delta_frame *frame);

int delta_get_free_frame(struct delta_ctx *ctx,
    struct delta_frame **pframe);

int delta_get_sync(struct delta_ctx *ctx);
void delta_put_autosuspend(struct delta_ctx *ctx);

#endif /* DELTA_H */