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.

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.

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).

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.

In v3.1, this also accepts JPEG images that carry an embedded Pixel/Google Motion Photo trailer: when ExifIter::has_embedded_track returned true for such a JPEG, calling parse_track on the same source extracts the embedded MP4’s metadata. Other image formats without an embedded track return crate::Error::TrackNotFound.

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

Parse Exif metadata from an in-memory byte payload built via MediaSource::<()>::from_bytes. Returns Error::ExifNotFound if the payload is a Track (use Self::parse_track_from_bytes instead).

Memory-mode parsing is zero-copy: the underlying Bytes is shared with the returned ExifIter (and its sub-IFDs / CR3 CMT blocks) via reference counting. No Vec<u8> is allocated for the parse buffer.

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

Parse track info from an in-memory video/audio byte payload built via MediaSource::<()>::from_bytes. Returns Error::TrackNotFound if the payload is an Image (use Self::parse_exif_from_bytes instead).

Like Self::parse_exif_from_bytes, the parse is zero-copy with respect to the user-supplied Bytes.

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.