o
    i%                     @   s   d Z ddlmZ ddlmZ ddlmZ ddlmZ ediZ	de
defd	d
ZdededefddZ	ddededededede
defddZdedefddZdedee fddZdS )zjUse Python to decode RLE Lossless encoded *Pixel Data*.

This module is not intended to be used directly.
    )unpack)warn_and_log)DecodeRunner)RLELossless uidreturnc                 C   s   | t v S )zeReturn ``True`` if a pixel data decoder for `uid` is available for use,
    ``False`` otherwise.
    )DECODER_DEPENDENCIES)r   r   r   Q/mnt/sdb/aimis/docanh/lib/python3.10/site-packages/pydicom/pixels/decoders/rle.pyis_available   s   r   srcrunnerc              
   C   s2   t | |j|j|j|j|dd}|dd |S )aK  Wrapper for use with the decoder interface.

    Parameters
    ----------
    src : bytes
        A single frame of RLE encoded data.
    runner : pydicom.pixels.decoders.base.DecodeRunner


        Required parameters:

        * `rows`: int
        * `columns`: int
        * `samples_per_pixel`: int
        * `bits_allocated`: int

        Optional parameters:

        * `rle_segment_order`: str, "<" for little endian segment order, or
          ">" for big endian (default)

    Returns
    -------
    bytearray
        The decoded frame, ordered as planar configuration 1.
    rle_segment_order>planar_configuration   )_rle_decode_framerowscolumnssamples_per_pixelbits_allocated
get_option
set_option)r   r   framer   r   r
   _decode_frame   s   

r   r   r   r   
nr_samplesnr_bitssegment_orderc                 C   s~  |d rt d| dt| dd }t|}|d }||| kr/td| d||  d|t|  t|| | | }	|| | }
t|D ]r}t|}|d	krV|nt|}|D ]_}|| | }t| || ||d
   }t|}||| k rtd| d||  d||| krt	d| d||  d |dkr|| d
 }|||
  }|d||  |	|||
 |< q\qJ|	S )a  Decodes a single frame of RLE encoded data.

    Each frame may contain up to 15 segments of encoded data.

    Parameters
    ----------
    src : bytes
        The RLE frame data
    rows : int
        The number of output rows
    columns : int
        The number of output columns
    nr_samples : int
        Number of samples per pixel (e.g. 3 for RGB data).
    nr_bits : int
        Number of bits per sample - must be a multiple of 8
    segment_order : str
        The segment order of the `data`, '>' for big endian (default),
        '<' for little endian (non-conformant).

    Returns
    -------
    bytearray
        The frame's decoded data in little endian and planar configuration 1
        byte ordering (i.e. for RGB data this is all red pixels then all
        green then all blue, with the bytes for each pixel ordered from
        MSB to LSB when reading left to right).
       z-Unable to decode RLE encoded pixel data with z bits allocatedN@   zPThe number of RLE segments in the pixel data doesn't match the expected amount (z vs. z
 segments)<r   zJThe amount of decoded RLE segment data doesn't match the expected amount (z bytes)z:The decoded RLE segment contains non-conformant padding - z bytes expectedr   )
NotImplementedError_rle_parse_headerlen
ValueErrorappend	bytearrayrangereversed_rle_decode_segmentr   )r   r   r   r   r   r   offsetsnr_segmentsbytes_per_sampledecodedstridesample_numberle_genbyte_offsetsbyte_offsetiisegmentactual_lengthstartr   r   r
   r   B   sb   $

r   c                 C   s   t  }d}|j}z5	 | | d }|d7 }|dkr+|| ||d  d|   |d7 }n|dk r=|| |||   ||7 }q
 tyG   Y |S w )zReturn a single segment of decoded RLE data as bytearray.

    Parameters
    ----------
    buffer : bytes
        The segment data to be decoded.

    Returns
    -------
    bytearray
        The decoded segment.
    r   Tr      i  )r&   extend
IndexError)r   resultposresult_extendheader_byter   r   r
   r)      s$   
r)   headerc                 C   sh   t | dkr
tdtd| dd d }|dkr!td| d	ttd
| d| dd|d   S )a  Return a list of byte offsets for the segments in RLE data.

    **RLE Header Format**

    The RLE Header contains the number of segments for the image and the
    starting offset of each segment. Each of these numbers is represented as
    an unsigned long stored in little-endian. The RLE Header is 16 long words
    in length (i.e. 64 bytes) which allows it to describe a compressed image
    with up to 15 segments. All unused segment offsets shall be set to zero.

    As an example, the table below describes an RLE Header with 3 segments as
    would typically be used with 8-bit RGB or YCbCr data (with 1 segment per
    channel).

    +--------------+---------------------------------+------------+
    | Byte  offset | Description                     | Value      |
    +==============+=================================+============+
    | 0            | Number of segments              | 3          |
    +--------------+---------------------------------+------------+
    | 4            | Offset of segment 1, N bytes    | 64         |
    +--------------+---------------------------------+------------+
    | 8            | Offset of segment 2, M bytes    | 64 + N     |
    +--------------+---------------------------------+------------+
    | 12           | Offset of segment 3             | 64 + N + M |
    +--------------+---------------------------------+------------+
    | 16           | Offset of segment 4 (not used)  | 0          |
    +--------------+---------------------------------+------------+
    | ...          | ...                             | 0          |
    +--------------+---------------------------------+------------+
    | 60           | Offset of segment 15 (not used) | 0          |
    +--------------+---------------------------------+------------+

    Parameters
    ----------
    header : bytes
        The RLE header data (i.e. the first 64 bytes of an RLE frame).

    Returns
    -------
    list of int
        The byte offsets for each segment in the RLE data.

    Raises
    ------
    ValueError
        If there are more than 15 segments or if the header is not 64 bytes
        long.

    References
    ----------
    DICOM Standard, Part 5, :dcm:`Annex G<part05/chapter_G.html>`
    r   z(The RLE header can only be 64 bytes longz<LN   r      z8The RLE header specifies an invalid number of segments ()r    Lr   )r#   r$   r   list)r>   r+   r   r   r
   r"      s   5
&r"   N)r   )__doc__structr   pydicom.miscr   pydicom.pixels.decoders.baser   pydicom.uidr   r	   strboolr   bytesr&   r   intr   r)   rC   r"   r   r   r   r
   <module>   s4   0
o'