content: {-# LANGUAGE OverloadedStrings, ScopedTypeVariables #-}
  {-# LANGUAGE ViewPatterns      #-}
  {-# OPTIONS_GHC -fno-warn-type-defaults #-}
  {- |
  Module      : Text.Pandoc.ImageSize
  Copyright   : Copyright (C) 2011-2024 John MacFarlane
  License     : GNU GPL, version 2 or above
  
  Maintainer  : John MacFarlane <jgm@berkeley.edu>
  Stability   : alpha
  Portability : portable
  
  Functions for determining the size of a PNG, JPEG, or GIF image.
  -}
  module Text.Pandoc.ImageSize ( ImageType(..)
                               , ImageSize(..)
                               , imageType
                               , imageSize
                               , sizeInPixels
                               , sizeInPoints
                               , desiredSizeInPoints
                               , Dimension(..)
                               , Direction(..)
                               , dimension
                               , lengthToDim
                               , scaleDimension
                               , inInch
                               , inPixel
                               , inPoints
                               , inEm
                               , numUnit
                               , showInInch
                               , showInPixel
                               , showFl
                               ) where
  import Data.ByteString (ByteString)
  import qualified Data.ByteString.Char8 as B
  import qualified Data.ByteString.Lazy as BL
  import Data.Binary.Get
  import Data.Bits ((.&.), shiftR, shiftL)
  import Data.Word (bitReverse32, Word32)
  import Data.Maybe (isJust, fromJust)
  import Data.Char (isDigit)
  import Control.Monad
  import Text.Pandoc.Shared (safeRead)
  import Data.Default (Default)
  import Numeric (showFFloat)
  import Text.Pandoc.Definition
  import Text.Pandoc.Options
  import qualified Text.Pandoc.UTF8 as UTF8
  import Text.Pandoc.XML.Light hiding (Attr)
  import qualified Data.Text as T
  import qualified Data.Text.Lazy as TL
  import qualified Data.Text.Encoding as TE
  import Control.Applicative
  import qualified Data.Attoparsec.ByteString as AW
  import qualified Data.Attoparsec.ByteString.Char8 as A
  import qualified Codec.Picture.Metadata as Metadata
  import Codec.Picture (decodeImageWithMetadata)
  import Codec.Compression.Zlib (decompress)
  -- import Debug.Trace
  
  -- quick and dirty functions to get image sizes
  
  data ImageType = Png | Gif | Jpeg | Svg | Pdf | Eps | Emf | Tiff | Webp | Avif
                   deriving Show
  data Direction = Width | Height
  instance Show Direction where
    show Width  = "width"
    show Height = "height"
  
  data Dimension = Pixel Integer
                 | Centimeter Double
                 | Millimeter Double
                 | Inch Double
                 | Point Double
                 | Pica Double
                 | Percent Double
                 | Em Double
                 deriving Eq
  
  instance Show Dimension where
    show (Pixel a)      = show a              ++ "px"
    show (Centimeter a) = T.unpack (showFl a) ++ "cm"
    show (Millimeter a) = T.unpack (showFl a) ++ "mm"
    show (Inch a)       = T.unpack (showFl a) ++ "in"
    show (Point a)      = T.unpack (showFl a) ++ "pt"
    show (Pica a)       = T.unpack (showFl a) ++ "pc"
    show (Percent a)    = show a              ++ "%"
    show (Em a)         = T.unpack (showFl a) ++ "em"
  
  data ImageSize = ImageSize{
                       pxX   :: Integer
                     , pxY   :: Integer
                     , dpiX  :: Integer
                     , dpiY  :: Integer
                     } deriving (Read, Show, Eq)
  instance Default ImageSize where
    def = ImageSize 300 200 72 72
  
  showFl :: (RealFloat a) => a -> T.Text
  showFl a = removeExtra0s $ T.pack $ showFFloat (Just 5) a ""
  
  removeExtra0s :: T.Text -> T.Text
  removeExtra0s s = case T.dropWhileEnd (=='0') s of
    (T.unsnoc -> Just (xs, '.')) -> xs
    xs                           -> xs
  
  dropBOM :: ByteString -> ByteString
  dropBOM bs =
   if "\xEF\xBB\xBF" `B.isPrefixOf` bs
      then B.drop 3 bs
      else bs
  
  imageType :: ByteString -> Maybe ImageType
  imageType img = case B.take 4 img of
                       "\x89\x50\x4e\x47" -> return Png
                       "\x47\x49\x46\x38" -> return Gif
                       "\x49\x49\x2a\x00" -> return Tiff
                       "\x4D\x4D\x00\x2a" -> return Tiff
                       "\xff\xd8\xff\xbd" -> return Jpeg  -- JPEG without application segment -- see p.32 in https://www.w3.org/Graphics/JPEG/itu-t81.pdf (and https://gist.github.com/leommoore/f9e57ba2aa4bf197ebc5?permalink_comment_id=3863054#gistcomment-3863054)
                       _ | B.take 3 img == "\xff\xd8\xff"
                            && (let byte4 = B.take 1 (B.drop 3 img)
                                in byte4 >= "\xe0" && byte4 <= "\xef")  -- JPEG with application segment
                                          -> return Jpeg
                       "%PDF"             -> return Pdf
                       "<svg"             -> return Svg
                       "<?xm"
                         | findSvgTag img
                                          -> return Svg
                       "%!PS"
                         |  B.take 4 (B.drop 1 $ B.dropWhile (/=' ') img) == "EPSF"
                                          -> return Eps
                       "\x01\x00\x00\x00"
                         | B.take 4 (B.drop 40 img) == " EMF"
                                          -> return Emf
                       "\xEF\xBB\xBF<" -- BOM before svg
                            -> imageType (B.drop 3 img)
                       "RIFF"
                         | B.take 4 (B.drop 8 img) == "WEBP"
                                          -> return Webp
                       _ | B.take 4 (B.drop 4 img) == "ftyp" -> return Avif
                       _ -> mzero
  
  findSvgTag :: ByteString -> Bool
  findSvgTag img = "<svg" `B.isInfixOf` img || "<SVG" `B.isInfixOf` img
  
  imageSize :: WriterOptions -> ByteString -> Either T.Text ImageSize
  imageSize opts img = checkDpi <$>
    case imageType img of
         Just Png  -> getSize img
         Just Gif  -> getSize img
         Just Jpeg -> getSize img
         Just Tiff -> getSize img
         Just Svg  -> mbToEither "could not determine SVG size" $ svgSize opts img
         Just Eps  -> mbToEither "could not determine EPS size" $ epsSize img
         Just Pdf  -> mbToEither "could not determine PDF size" $ pdfSize img
         Just Emf  -> mbToEither "could not determine EMF size" $ emfSize img
         Just Webp -> mbToEither "could not determine WebP size" $ webpSize opts img
         Just Avif -> mbToEither "could not determine AVIF size" $ avifSize opts img
         Nothing   -> Left "could not determine image type"
    where mbToEither msg Nothing  = Left msg
          mbToEither _   (Just x) = Right x
          -- see #6880, some defective JPEGs may encode dpi 0, so default to 72
          -- if that value is 0
          checkDpi size =
            size{ dpiX = if dpiX size == 0 then 72 else dpiX size
                , dpiY = if dpiY size == 0 then 72 else dpiY size }
  
  
  sizeInPixels :: ImageSize -> (Integer, Integer)
  sizeInPixels s = (pxX s, pxY s)
  
  -- | Calculate (height, width) in points using the image file's dpi metadata,
  -- using 72 Points == 1 Inch.
  sizeInPoints :: ImageSize -> (Double, Double)
  sizeInPoints s = (pxXf * 72 / dpiXf, pxYf * 72 / dpiYf)
    where
      pxXf  = fromIntegral $ pxX s
      pxYf  = fromIntegral $ pxY s
      dpiXf = fromIntegral $ dpiX s
      dpiYf = fromIntegral $ dpiY s
  
  -- | Calculate (height, width) in points, considering the desired dimensions in the
  -- attribute, while falling back on the image file's dpi metadata if no dimensions
  -- are specified in the attribute (or only dimensions in percentages).
  desiredSizeInPoints :: WriterOptions -> Attr -> ImageSize -> (Double, Double)
  desiredSizeInPoints opts attr s =
    case (getDim Width, getDim Height) of
      (Just w, Just h)   -> (w, h)
      (Just w, Nothing)  -> (w, w / ratio)
      (Nothing, Just h)  -> (h * ratio, h)
      (Nothing, Nothing) -> sizeInPoints s
    where
      ratio = fromIntegral (pxX s) / fromIntegral (pxY s)
      getDim dir = case dimension dir attr of
                     Just (Percent _) -> Nothing
                     Just dim         -> Just $ inPoints opts dim
                     Nothing          -> Nothing
  
  inPoints :: WriterOptions -> Dimension -> Double
  inPoints opts dim = 72 * inInch opts dim
  
  inEm :: WriterOptions -> Dimension -> Double
  inEm opts dim = (64/11) * inInch opts dim
  
  inInch :: WriterOptions -> Dimension -> Double
  inInch opts dim =
    case dim of
      (Pixel a)      -> fromIntegral a / fromIntegral (writerDpi opts)
      (Centimeter a) -> a * 0.3937007874
      (Millimeter a) -> a * 0.03937007874
      (Inch a)       -> a
      (Point a)      -> (a / 72)
      (Pica a)       -> (a / 6)
      (Percent _)    -> 0
      (Em a)         -> a * (11/64)
  
  inPixel :: WriterOptions -> Dimension -> Integer
  inPixel opts dim =
    case dim of
      (Pixel a)      -> a
      _              -> floor (dpi * inInch opts dim)
    where
      dpi = fromIntegral $ writerDpi opts
  
  -- | Convert a Dimension to Text denoting its equivalent in inches, for example "2.00000".
  -- Note: Dimensions in percentages are converted to the empty string.
  showInInch :: WriterOptions -> Dimension -> T.Text
  showInInch _ (Percent _) = ""
  showInInch opts dim = showFl $ inInch opts dim
  
  -- | Convert a Dimension to Text denoting its equivalent in pixels, for example "600".
  -- Note: Dimensions in percentages are converted to the empty string.
  showInPixel :: WriterOptions -> Dimension -> T.Text
  showInPixel _ (Percent _) = ""
  showInPixel opts dim = T.pack $ show $ inPixel opts dim
  
  -- | Maybe split a string into a leading number and trailing unit, e.g. "3cm" to Just (3.0, "cm")
  numUnit :: T.Text -> Maybe (Double, T.Text)
  numUnit s =
    let (nums, unit) = T.span (\c -> isDigit c || ('.'==c)) s
    in (\n -> (n, unit)) <$> safeRead nums
  
  -- | Scale a dimension by a factor.
  scaleDimension :: Double -> Dimension -> Dimension
  scaleDimension factor dim =
    case dim of
          Pixel x      -> Pixel (round $ factor * fromIntegral x)
          Centimeter x -> Centimeter (factor * x)
          Millimeter x -> Millimeter (factor * x)
          Inch x       -> Inch (factor * x)
          Point x      -> Point (factor * x)
          Pica x       -> Pica (factor * x)
          Percent x    -> Percent (factor * x)
          Em x         -> Em (factor * x)
  
  -- | Read a Dimension from an Attr attribute.
  -- `dimension Width attr` might return `Just (Pixel 3)` or for example `Just (Centimeter 2.0)`, etc.
  dimension :: Direction -> Attr -> Maybe Dimension
  dimension dir (_, _, kvs) =
    case dir of
      Width  -> extractDim "width"
      Height -> extractDim "height"
    where
      extractDim key = lookup key kvs >>= lengthToDim
  
  lengthToDim :: T.Text -> Maybe Dimension
  lengthToDim s = numUnit s >>= uncurry toDim
    where
      toDim a "cm"   = Just $ Centimeter a
      toDim a "mm"   = Just $ Millimeter a
      toDim a "in"   = Just $ Inch a
      toDim a "inch" = Just $ Inch a
      toDim a "%"    = Just $ Percent a
      toDim a "px"   = Just $ Pixel (floor a::Integer)
      toDim a ""     = Just $ Pixel (floor a::Integer)
      toDim a "pt"   = Just $ Point a
      toDim a "pc"   = Just $ Pica a
      toDim a "em"   = Just $ Em a
      toDim _ _      = Nothing
  
  epsSize :: ByteString -> Maybe ImageSize
  epsSize img = do
    let ls = takeWhile ("%" `B.isPrefixOf`) $ B.lines img
    let ls' = dropWhile (not . ("%%BoundingBox:" `B.isPrefixOf`)) ls
    case ls' of
         []    -> mzero
         (x:_) -> case B.words x of
                       [_, _, _, ux, uy] -> do
                          ux' <- safeRead $ TE.decodeUtf8 ux
                          uy' <- safeRead $ TE.decodeUtf8 uy
                          return ImageSize{
                              pxX  = ux'
                            , pxY  = uy'
                            , dpiX = 72
                            , dpiY = 72 }
                       _ -> mzero
  
  pdfSize :: ByteString -> Maybe ImageSize
  pdfSize img =
    case A.parseOnly pPdfSize img of
      Left _   -> Nothing
      Right sz -> Just sz
  
  pPdfSize :: A.Parser ImageSize
  pPdfSize =
    (A.takeWhile1 (/= '/') *> pPdfSize)
    <|>
    (do A.string "/MediaBox"
        A.skipSpace
        A.char8 '['
        A.skipSpace
        [x1,y1,x2,y2] <- A.count 4 $ do
          A.skipSpace
          raw <- A.many1 $ A.satisfy (\c -> isDigit c || c == '.')
          case safeRead $ T.pack raw of
            Just (r :: Double) -> return $ floor r
            Nothing            -> mzero
        A.skipSpace
        A.char8 ']'
        return $ ImageSize{
                pxX  = x2 - x1
              , pxY  = y2 - y1
              , dpiX = 72
              , dpiY = 72 }
    )
    <|> -- if we encounter a compressed object stream, uncompress it (#10902)
    (do A.string "/Type"
        A.skipSpace
        A.string "/ObjStm"
        _ <- A.manyTill pLine (A.string "stream" *> pEol)
        stream <- BL.pack <$> A.manyTill
                          (AW.satisfy (const True))
                          (pEol *> A.string "endstream" *> pEol)
        let contents = BL.toStrict (decompress stream)
        case A.parseOnly pPdfSize contents of
          Left _ -> pPdfSize
          Right is -> pure is)
    <|>
    (A.char '/' *> pPdfSize)
   where
     iseol '\r' = True
     iseol '\n' = True
     iseol _ = False
     pEol = A.satisfy iseol *> A.skipMany (A.satisfy iseol)
     pLine = A.takeWhile (not . iseol) <* pEol
  
  getSize :: ByteString -> Either T.Text ImageSize
  getSize img =
    case decodeImageWithMetadata img of
      Left e -> Left (T.pack e)
      Right (_, meta) -> do
        pxx <- maybe (Left "Could not determine width") Right $
                     Metadata.lookup Metadata.Width meta
        pxy <- maybe (Left "Could not determine height") Right $
                     Metadata.lookup Metadata.Height meta
        dpix <- maybe (Right 72) Right $ Metadata.lookup Metadata.DpiX meta
        dpiy <- maybe (Right 72) Right $ Metadata.lookup Metadata.DpiY meta
        return $ ImageSize
                  { pxX = fromIntegral pxx
                  , pxY = fromIntegral pxy
                  , dpiX = fromIntegral dpix
                  , dpiY = fromIntegral dpiy }
  
  svgSize :: WriterOptions -> ByteString -> Maybe ImageSize
  svgSize opts img = do
    doc <- either (const mzero) return $ parseXMLElement
                                       $ TL.fromStrict $ UTF8.toText $ dropBOM img
    let viewboxSize = do
          vb <- findAttrBy (== QName "viewBox" Nothing Nothing) doc
          [_,_,w,h] <- mapM safeRead (T.words vb)
          return (w,h)
    let dpi = fromIntegral $ writerDpi opts
    let dirToInt dir = do
          dim <- findAttrBy (== QName dir Nothing Nothing) doc >>= lengthToDim
          return $ inPixel opts dim
    w <- dirToInt "width" <|> (fst <$> viewboxSize)
    h <- dirToInt "height" <|> (snd <$> viewboxSize)
    return ImageSize {
      pxX  = w
    , pxY  = h
    , dpiX = dpi
    , dpiY = dpi
    }
  
  emfSize :: ByteString -> Maybe ImageSize
  emfSize img =
    let
      parseheader = runGetOrFail $ do
        skip 0x18             -- 0x00
        frameL <- getWord32le -- 0x18  measured in 1/100 of a millimetre
        frameT <- getWord32le -- 0x1C
        frameR <- getWord32le -- 0x20
        frameB <- getWord32le -- 0x24
        skip 0x20             -- 0x28
        deviceX <- getWord32le  -- 0x48 pixels of reference device
        deviceY <- getWord32le  -- 0x4C
        mmX <- getWord32le      -- 0x50 real mm of reference device (always 320*240?)
        mmY <- getWord32le      -- 0x58
        -- end of header
        let
          w = (deviceX * (frameR - frameL)) `quot` (mmX * 100)
          h = (deviceY * (frameB - frameT)) `quot` (mmY * 100)
          dpiW = (deviceX * 254) `quot` (mmX * 10)
          dpiH = (deviceY * 254) `quot` (mmY * 10)
        return $ ImageSize
          { pxX = fromIntegral w
          , pxY = fromIntegral h
          , dpiX = fromIntegral dpiW
          , dpiY = fromIntegral dpiH
          }
    in
      case parseheader . BL.fromStrict $ img of
        Left _ -> Nothing
        Right (_, _, size) -> Just size
  
  -- See https://developers.google.com/speed/webp/docs/riff_container
  -- and RFC 6386
  pWebpSize :: AW.Parser ImageSize
  pWebpSize = do
    AW.string "RIFF"
    AW.take 4
    AW.string "WEBP"
    (w, h) <- lossy <|> lossless <|> extended
    return $ def
      { pxX = w
      , pxY = h
      }
    where
      bitsToMaybe = either (const Nothing) (\((_, _, s)) -> Just s)
      decode d = bitsToMaybe . d . BL.fromStrict
      lossySize = runGetOrFail $ do
        word <- getWord16le
        return $ word .&. 0x3FFF
      lossy = do
        AW.string "VP8 "
        AW.take 4 -- length in bytes of VP8 Lossy stream size
        keyFrame <-  AW.anyWord8
        guard $ keyFrame .&. 1 == 0
        AW.take 2 -- remaining bytes of frame header
        AW.word8 0x9d  -- VP8 keyframe magic
        AW.word8 0x01
        AW.word8 0x2a
        width16 <- AW.take 2
        height16 <- AW.take 2
        let w = toInteger <$> decode lossySize width16
            h = toInteger <$> decode lossySize height16
        guard $ isJust w && isJust h
        return (fromJust w, fromJust h)
      losslessSizes = runGetOrFail $ do
        bitReverse32 <$> getWord32le
      losslessSize word = 1 + (word .&. 0x3FFF)
      lossless = do
        AW.string "VP8L"
        AW.take 4 -- length in bytes of VP8 Lossless chunk size
        AW.word8 0x2f  -- webp lossless stream magic
        sizes <- AW.take 4
        let mbword = decode losslessSizes sizes
        guard $ isJust mbword
        let word = fromJust mbword
        let w = toInteger $ losslessSize word
            h = toInteger $ losslessSize (word `shiftR` 14)
        return (w, h)
      extendedSize = runGetOrFail $ do
        low <- toInteger <$> getWord16le
        high <- toInteger <$> getWord8
        return $ 1 + (high `shiftL` 16) + (low)
      extended = do
        AW.string "VP8X"
        AW.take 8  -- VP8X chunk length, flags and reserved area
        width24 <- AW.take 3
        height24 <- AW.take 3
        let w = decode extendedSize width24
            h = decode extendedSize height24
        guard $ isJust w && isJust h
        return (fromJust w, fromJust h)
  
  webpSize :: WriterOptions -> ByteString -> Maybe ImageSize
  webpSize opts img =
    case AW.parseOnly pWebpSize img of
      Left _   -> Nothing
      Right sz -> Just sz { dpiX = fromIntegral $ writerDpi opts, dpiY = fromIntegral $ writerDpi opts}
  
  avifSize :: WriterOptions -> ByteString -> Maybe ImageSize
  avifSize _opts img =
    case runGetOrFail (verifyFtyp >> findAvifDimensions) (BL.fromStrict img) of
      Left (_, _, _err) -> Nothing
      Right (_, _, (width, height)) ->
        Just $ ImageSize { pxX = fromIntegral width
                         , pxY = fromIntegral height
                         , dpiX = 72
                         , dpiY = 72 }
  
  ---- AVIF parsing:
  
  verifyFtyp :: Get ()
  verifyFtyp = do
    ftypSize <- getWord32be
    when (ftypSize < 16) $ fail "Invalid ftyp size"
  
    ftyp <- getByteString 4
    unless (ftyp == "ftyp") $ fail "ftyp signature not found"
  
    brand <- getByteString 4
    unless (brand == "avif" || brand == "avis") $ fail "Not an AVIF file"
  
    -- Skip minor version and compatible brands
    -- (we've read 12 bytes: size+type+brand)
    let remaining_ftyp = fromIntegral ftypSize - 12
    when (remaining_ftyp > 0) $ skip remaining_ftyp
  
  findAvifDimensions :: Get (Word32, Word32)
  findAvifDimensions = searchAvifBoxes []
  
  searchAvifBoxes :: [B.ByteString] -> Get (Word32, Word32)
  searchAvifBoxes path = do
    isempty <- isEmpty
    if isempty
      then fail $ "No dimensions found. Searched: " ++ show (reverse path)
      else do
        boxSize <- getWord32be
        boxType <- getByteString 4
  
        let contentSize = fromIntegral boxSize - 8
        let newPath = boxType : path
  
        -- If it's a container box, search inside it
        if isContainerBox boxType
          then searchInsideBox contentSize newPath
          else do
            -- Try to parse dimensions from this box
            result <- tryParseDimensions boxType contentSize
            case result of
              Just dims -> return dims
              Nothing -> do
                -- Skip this box and continue
                when (contentSize > 0 && contentSize < 10000000) $
                  skip contentSize
                searchAvifBoxes path
  
  tryParseDimensions :: B.ByteString -> Int -> Get (Maybe (Word32, Word32))
  tryParseDimensions boxType size = do
    pos <- bytesRead
    result <- case boxType of
      "ispe" -> parseIspeBox
      "tkhd" -> parseTkhdBox
      "stsd" -> parseStsdBox
      "av01" -> parseAv01Box
      _ -> return Nothing
  
    -- Reset position if we didn't find dimensions
    case result of
      Nothing -> do
        newPos <- bytesRead
        let consumed = fromIntegral (newPos - pos)
        case size - consumed of
          n | n > 0 -> skip n
          _ -> return ()
      Just _ -> return ()
  
    return result
  
  parseIspeBox :: Get (Maybe (Word32, Word32))
  parseIspeBox = do
    skip 4  -- version/flags
    width <- getWord32be
    height <- getWord32be
    return $ Just (width, height)
  
  parseTkhdBox :: Get (Maybe (Word32, Word32))
  parseTkhdBox = do
    version <- getWord8
    skip 3  -- flags
  
    -- Skip to width/height based on version
    let skipBytes = if version == 1 then 76 else 64
    skip skipBytes
  
    width <- getWord32be
    height <- getWord32be
    -- Convert from 16.16 fixed point
    return $ Just (width `shiftR` 16, height `shiftR` 16)
  
  parseStsdBox :: Get (Maybe (Word32, Word32))
  parseStsdBox = do
    skip 8  -- version, flags, entry count
    findAv01Entry
  
  findAv01Entry :: Get (Maybe (Word32, Word32))
  findAv01Entry = do
    entrySize <- getWord32be
    codec <- getByteString 4
  
    if codec == "av01"
      then do
        skip 6  -- reserved
        skip 2  -- data reference index
        skip 16 -- pre-defined + reserved
        width <- getWord16be
        height <- getWord16be
        return $ Just (fromIntegral width, fromIntegral height)
      else do
        let skipSize = fromIntegral entrySize - 8
        when (skipSize > 0) $ skip skipSize
        findAv01Entry
  
  parseAv01Box :: Get (Maybe (Word32, Word32))
  parseAv01Box = do
    skip 6   -- reserved
    skip 2   -- data reference index
    skip 16  -- predefined/reserved
    width <- getWord16be
    height <- getWord16be
    return $ Just (fromIntegral width, fromIntegral height)
  
  searchInsideBox :: Int -> [B.ByteString] -> Get (Word32, Word32)
  searchInsideBox size path = do
    -- For meta boxes, skip version/flags
    let isMeta = case path of
                   "meta":_ -> True
                   _ -> False
    when isMeta $ skip 4
  
    let searchSize = if isMeta then size - 4 else size
    searchAvifBoxesInRange searchSize path
  
  searchAvifBoxesInRange :: Int -> [B.ByteString] -> Get (Word32, Word32)
  searchAvifBoxesInRange remaining' path
    | remaining' < 8 = searchAvifBoxes path
    | otherwise = do
        boxSize <- getWord32be
        boxType <- getByteString 4
  
        let contentSize = fromIntegral boxSize - 8
        let newPath = boxType : path
  
        when (contentSize < 0 || fromIntegral boxSize > remaining') $ do
          fail $ "Malformed box at path: " ++ show (reverse newPath)
  
        if isContainerBox boxType
          then searchInsideBox contentSize newPath
          else do
            result <- tryParseDimensions boxType contentSize
            case result of
              Just dims -> return dims
              Nothing -> do
                -- Don't skip here - tryParseDimensions already handled it
                searchAvifBoxesInRange (remaining' - fromIntegral boxSize) path
  
  isContainerBox :: B.ByteString -> Bool
  isContainerBox boxType = boxType `elem`
    ["moov", "trak", "mdia", "minf", "stbl", "meta", "dinf", "ipco", "iprp"]
  