Struct MediaParser 

pub struct MediaParser { /* private fields */ }

A MediaParser can parse media info from a MediaSource.

MediaParser manages inner parse buffers that can be shared between multiple parsing tasks, thus avoiding frequent memory allocations.

Therefore:

• Try to reuse a MediaParser instead of creating a new one every time you need it.

• MediaSource should be created directly from Read, not from BufRead.

Example

use nom_exif::*;
use chrono::DateTime;

let mut parser = MediaParser::new();

// ------------------- Parse Exif Info
let ms = MediaSource::open("./testdata/exif.heic").unwrap();
assert_eq!(ms.kind(), MediaKind::Image);
let mut iter = parser.parse_exif(ms).unwrap();

let entry = iter.next().unwrap();
assert!(matches!(entry.tag(), nom_exif::TagOrCode::Tag(ExifTag::Make)));
assert_eq!(entry.value().unwrap().as_str().unwrap(), "Apple");

// Convert `ExifIter` into an `Exif`. Clone it before converting, so that
// we can start the iteration from the beginning.
let exif: Exif = iter.clone().into();
assert_eq!(exif.get(ExifTag::Make).unwrap().as_str().unwrap(), "Apple");

// ------------------- Parse Track Info
let ms = MediaSource::open("./testdata/meta.mov").unwrap();
assert_eq!(ms.kind(), MediaKind::Track);
let info = parser.parse_track(ms).unwrap();

assert_eq!(info.get(TrackInfoTag::Make), Some(&"Apple".into()));
assert_eq!(info.get(TrackInfoTag::Model), Some(&"iPhone X".into()));
assert_eq!(info.get(TrackInfoTag::GpsIso6709), Some(&"+27.1281+100.2508+000.000/".into()));
assert_eq!(info.gps_info().unwrap().latitude_ref, LatRef::North);
assert_eq!(
    info.gps_info().unwrap().latitude,
    LatLng::new(URational::new(27, 1), URational::new(7, 1), URational::new(4116, 100)),
);

Implementations

impl MediaParser

pub async fn parse_exif_async<R: AsyncRead + Unpin + Send>( &mut self, ms: AsyncMediaSource<R>, ) -> Result<ExifIter>

Parse Exif metadata from an async image source. Returns Error::ExifNotFound if the source is a Track.

As of v3.3, also accepts memory-mode sources built via AsyncMediaSource::from_memory; the memory branch shares caller-owned Bytes zero-copy through state.set_memory.

pub async fn parse_image_metadata_async<R: AsyncRead + Unpin + Send>( &mut self, ms: AsyncMediaSource<R>, ) -> Result<ImageMetadata<ExifIter>>

pub async fn parse_track_async<R: AsyncRead + Unpin + Send>( &mut self, ms: AsyncMediaSource<R>, ) -> Result<TrackInfo>

Parse track info from an async video/audio source. Returns Error::TrackNotFound if the source is an Image.

As of v3.3, also accepts memory-mode sources built via AsyncMediaSource::from_memory.

impl MediaParser

pub fn new() -> Self

pub fn parse_exif<R: Read>(&mut self, ms: MediaSource<R>) -> Result<ExifIter>

Parse Exif metadata from an image source. Returns Error::ExifNotFound if the source is a Track (use Self::parse_track instead).

As of v3.3, this method also accepts memory-mode sources built via MediaSource::from_memory. The deprecated Self::parse_exif_from_bytes is now a thin adapter that delegates here.

MediaParser reuses its internal parse buffer across calls, so prefer reusing a single MediaParser over creating a new one per file. Drop the returned ExifIter (or convert it into crate::Exif) before the next parse_* call so the buffer can be reclaimed.

pub fn parse_track<R: Read>(&mut self, ms: MediaSource<R>) -> Result<TrackInfo>

Parse track info from a video/audio source.

Parse track info from a video/audio source.

In v3.1, this also accepts JPEG images that carry an embedded Pixel/Google Motion Photo trailer. As of v3.3, it also accepts memory-mode sources built via MediaSource::from_memory; the deprecated Self::parse_track_from_bytes is now a thin adapter that delegates here.

pub fn parse_exif_from_bytes(&mut self, ms: MediaSource<()>) -> Result<ExifIter>

👎Deprecated since 3.3.0:

Use parse_exif directly — it now accepts memory-mode sources built via MediaSource::from_memory.

Parse Exif metadata from an in-memory byte payload built via the deprecated MediaSource::<()>::from_bytes.

Deprecated since v3.3.0: use Self::parse_exif with MediaSource::from_memory directly.

pub fn parse_track_from_bytes( &mut self, ms: MediaSource<()>, ) -> Result<TrackInfo>

👎Deprecated since 3.3.0:

Use parse_track with MediaSource::from_memory.

Deprecated since v3.3.0: use Self::parse_track with MediaSource::from_memory directly.

pub fn parse_image_metadata<R: Read>( &mut self, ms: MediaSource<R>, ) -> Result<ImageMetadata<ExifIter>>

Parse all metadata from an image source: EXIF (if any) and format-specific extras (PNG tEXt chunks, etc.).

Returns Err(Error::ExifNotFound) if neither EXIF nor any format-specific metadata is found. Returns Err(Error::TrackNotFound)-style errors on track inputs (use parse_track instead).

Lazy form — this method returns ImageMetadata<ExifIter>. Convert to the eager ImageMetadata<Exif> via .into() if desired.

Trait Implementations

impl Debug for MediaParser

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for MediaParser

fn default() -> Self

Returns the “default value” for a type.