Struct ParserConfig 

pub struct ParserConfig {
    pub extract_images: bool,
    pub compress_images: bool,
    pub quality: u8,
    pub image_handling_mode: ImageHandlingMode,
    pub image_output_path: Option<PathBuf>,
    pub include_slide_comment: bool,
}

Configuration options for the PPTX parser.

Use ParserConfig::builder() to create a configuration instance. This allows you to customize only the desired fields while falling back to sensible defaults for the rest.

Configuration Options

Parameter	Type	Default	Description
extract_images	bool	true	Whether images are extracted from slides or not. If false, images can not be extracted manually either
compress_images	bool	true	Whether images are compressed before encoding or not. Effects manually extracted images too
image_quality	u8	80	Compression level (0-100); higher values retain more detail but increase file size
image_handling_mode	ImageHandlingMode	InMarkdown	Determines how images are handled during content export
image_output_path	Option<PathBuf>	None	Output directory path for ImageHandlingMode::Save (mandatory for the saving mode)
include_slide_comment	bool	true	Weather the slide number comment is included or not (<!-- Slide [n] -->)

Example

use std::path::PathBuf;
use pptx_to_md::{ImageHandlingMode, ParserConfig};

let config = ParserConfig::builder()
    .extract_images(true)
    .compress_images(true)
    .quality(75)
    .image_handling_mode(ImageHandlingMode::Save)
    .image_output_path(PathBuf::from("/path/to/output/dir/"))
    .build();

Fields

extract_images: bool

compress_images: bool

quality: u8

image_handling_mode: ImageHandlingMode

image_output_path: Option<PathBuf>

include_slide_comment: bool

Implementations

impl ParserConfig

pub fn builder() -> ParserConfigBuilder

Examples found in repository

examples/save_images.rs (line 26)

fn main() -> Result<()> {
    // Get the PPTX file path from command line arguments and provide the mandatory output path
    let args: Vec<String> = env::args().collect();
    let pptx_path = if args.len() > 1 {
        &args[1]
    } else {
        eprintln!("Usage: cargo run --example save_images <path/to/presentation.pptx>");
        return Ok(());
    };

    println!("Processing PPTX file: {}", pptx_path);

    // Use the config builder to build your config
    let config = ParserConfig::builder()
        .extract_images(true)
        .compress_images(true)
        .quality(75)
        .image_handling_mode(ImageHandlingMode::Save)
        .image_output_path(PathBuf::from("C:/Users/nilsk/Downloads/extracted_images"))
        .build();

    // Open the PPTX file
    let mut container = PptxContainer::open(Path::new(pptx_path), config)?;

    // Parse all slides
    let slides = container.parse_all()?;

    println!("Found {} slides", slides.len());

    // create a new Markdown file
    let mut md_file = File::create("output.md")?;

    // Convert each slide to Markdown and save the images automatically
    for slide in slides {
        if let Some(md_content) = slide.convert_to_md() {
            writeln!(md_file, "{}", md_content).expect("Couldn't write to file");
        }
    }

    println!("All slides converted successfully!");

    Ok(())
}

examples/memory_efficient_streaming.rs (line 26)

fn main() -> Result<()> {
    // Get the PPTX file path from command line arguments
    let args: Vec<String> = env::args().collect();
    let pptx_path = if args.len() > 1 {
        &args[1]
    } else {
        eprintln!("Usage: cargo run --example memory_efficient_streaming <path/to/presentation.pptx>");
        return Ok(());
    };

    println!("Processing PPTX file: {}", pptx_path);

    // Use the config builder to build your config
    let config = ParserConfig::builder()
        .extract_images(true)
        .build();
    
    // Open the PPTX file with the streaming API
    let mut streamer = PptxContainer::open(Path::new(pptx_path), config)?;
    
    // Create output directory
    let output_dir = "output_streaming";
    fs::create_dir_all(output_dir)?;

    // Process slides one by one using the iterator
    for slide_result in streamer.iter_slides() {
        match slide_result {
            Ok(slide) => {
                println!("Processing slide {} ({} elements)", slide.slide_number, slide.elements.len());

                if let Some(md_content) = slide.convert_to_md() {
                    let output_path = format!("{}/slide_{}.md", output_dir, slide.slide_number);
                    fs::write(&output_path, md_content)?;
                    println!("Saved slide {} to {}", slide.slide_number, output_path);
                }
            },
            Err(e) => {
                eprintln!("Error processing slide: {:?}", e);
            }
        }
    }

    println!("All slides processed successfully!");

    Ok(())
}

examples/basic_usage.rs (line 33)

fn main() -> Result<()> {
    // Get the PPTX file path from command line arguments
    let args: Vec<String> = env::args().collect();
    let pptx_path = if args.len() > 1 {
        &args[1]
    } else {
        eprintln!("Usage: cargo run --example basic_usage <path/to/presentation.pptx> <extract_images>\ncargo run --example basic_usage sample.pptx true");
        return Ok(());
    };
    
    // Tries to read if the extract_images flag is false else set to true
    let extract_images = if args.len() > 2 {
        !(args[2] == "false" || args[2] == "False" || args[2] == "0")
    } else {
        true
    };
    
    println!("Processing PPTX file: {}", pptx_path);

    // Use the config builder to build your config
    let config = ParserConfig::builder()
        .extract_images(extract_images)
        .compress_images(true)
        .quality(75)
        .image_handling_mode(ImageHandlingMode::InMarkdown)
        .include_slide_comment(true)
        .build();
    
    // Open the PPTX file
    let mut container = PptxContainer::open(Path::new(pptx_path), config)?;

    // Parse all slides
    let slides = container.parse_all()?;

    println!("Found {} slides", slides.len());

    // create a new Markdown file
    let mut md_file = File::create("output.md")?;

    // Convert each slide to Markdown and save
    for slide in slides {
        if let Some(md_content) = slide.convert_to_md() {
            println!("{}", md_content);
            writeln!(md_file, "{}", md_content).expect("Couldn't write to file");
        }
    }

    println!("All slides converted successfully!");

    Ok(())
}

examples/slide_elements.rs (line 25)

fn main() -> Result<()> {
    // Get the PPTX file path from command line arguments
    let args: Vec<String> = env::args().collect();
    let pptx_path = if args.len() > 1 {
        &args[1]
    } else {
        eprintln!("Usage: cargo run --example slide_elements <path/to/presentation.pptx>");
        return Ok(());
    };

    println!("Processing PPTX file: {}", pptx_path);

    // Use the config builder to build your config
    let config = ParserConfig::builder()
        .extract_images(true)
        .build();
    
    // Open the PPTX file with the streaming API
    let mut streamer = PptxContainer::open(Path::new(pptx_path), config)?;

    // Process slides one by one using the iterator
    for slide_result in streamer.iter_slides() {
        match slide_result {
            Ok(slide) => {
                println!("Processing slide {} ({} elements)", slide.slide_number, slide.elements.len());

                // iterate over each slide element and match them to add custom logic
                for element in &slide.elements {
                    match element {
                        SlideElement::Text(text, pos) => { println!("{:?}\t{:?}\n", text, pos) }
                        SlideElement::Table(table, pos) => { println!("{:?}\t{:?}\n", table, pos) }
                        SlideElement::Image(image, pos) => { println!("{:?}\t{:?}\n", image, pos) }
                        SlideElement::List(list, pos) => { println!("{:?}\t{:?}\n", list, pos) }
                        SlideElement::Unknown => { println!("An Unknown element was found.\n") }
                    }
                }
            },
            Err(e) => {
                eprintln!("Error processing slide: {:?}", e);
            }
        }
    }

    println!("All slides processed successfully!");

    Ok(())
}

examples/manual_image_extraction.rs (line 28)

fn main() -> Result<()> {
    // Get the PPTX file path from command line arguments
    let args: Vec<String> = env::args().collect();
    let pptx_path = if args.len() > 1 {
        &args[1]
    } else {
        eprintln!("Usage: cargo run --example manual_image_extraction <path/to/presentation.pptx>");
        return Ok(());
    };

    println!("Processing PPTX file: {}", pptx_path);

    // Use the config builder to build your config
    let config = ParserConfig::builder()
        .extract_images(true)
        .compress_images(true)
        .quality(75)
        .image_handling_mode(ImageHandlingMode::Manually)
        .build();

    // Open the PPTX file
    let mut container = PptxContainer::open(Path::new(pptx_path), config)?;

    // Parse all slides
    let slides = container.parse_all()?;

    println!("Found {} slides", slides.len());

    // create a new Markdown file
    let mut md_file = File::create("output.md")?;

    // Create output directory
    let output_dir = "extracted_images";
    fs::create_dir_all(output_dir)?;

    // Process slides one by one using the iterator
    let mut image_count = 1;

    // Convert each slide to Markdown and save
    for slide in slides {
        if let Some(md_content) = slide.convert_to_md() {
            writeln!(md_file, "{}", md_content).expect("Couldn't write to file");
        }
        
        // Manually load the base64 encoded image strings from the slide
        if let Some(images) = slide.load_images_manually() {
            for image in images {
                
                // Decode the base64 strings back to raw image data
                let image_data = general_purpose::STANDARD.decode(image.base64_content.clone()).unwrap();

                // Extract image extension if the image is not compressed, otherwise its always `.jpg`
                let ext = slide.config.compress_images
                    .then(|| "jpg".to_string())
                    .unwrap_or_else(|| slide.get_image_extension(&image.img_ref.target.clone()));

                // Construct a unique file name
                let file_name = format!("slide{}_image{}_{}", slide.slide_number, image_count, &image.img_ref.id);
                
                // Save the image
                let output_path = format!(
                    "{}/{}.{}",
                    output_dir,
                    &file_name,
                    ext
                );
                fs::write(&output_path, image_data)?;
                println!("Saved image to {}", output_path);

                // Write the image data into the Markdown file
                writeln!(md_file, "![{}](data:image/{};base64,{})", file_name, ext, image.base64_content).expect("Couldn't write to file");
                
                image_count += 1;
            }
        }
    }

    println!("All slides converted successfully!");

    Ok(())
}

examples/performance_test.rs (line 100)

fn main() -> Result<()> {
    // Get the PPTX file path and optional iteration count from command line arguments
    let args: Vec<String> = env::args().collect();
    let pptx_path = if args.len() > 1 {
        &args[1]
    } else {
        eprintln!("Usage: cargo run --example performance_test <path/to/presentation.pptx> [iterations]");
        return Ok(());
    };

    let iterations = if args.len() > 2 {
        args[2].parse().unwrap_or(5)
    } else {
        10 // Default to 10 iterations
    };

    println!("Performance testing with {} iterations on: {}", iterations, pptx_path);

    
    
    // =========== Single-threaded Approach ===========
    let mut single_thread_bench = Benchmark::new("Single-threaded parsing");

    let mut total_slides = 0;

    for i in 0..iterations {
        println!("\nIteration {} (Single-threaded)", i + 1);

        // Measure container creation
        let mut container = single_thread_bench.measure(|| {
            let config = ParserConfig::builder()
                .extract_images(true)
                .build();
            PptxContainer::open(Path::new(pptx_path), config).expect("Failed to open PPTX")
        });

        println!("  Found {} slides in the presentation", container.slide_count);

        // Measure parsing
        let slides = single_thread_bench.measure(|| {
            container.parse_all().expect("Failed to parse slides")
        });

        // Measure conversion
        let _md_content = single_thread_bench.measure(|| {
            slides.iter()
                .filter_map(|slide| slide.convert_to_md())
                .collect::<Vec<String>>()
        });

        total_slides += slides.len();
    }

    single_thread_bench.report();
    println!("Average slides per presentation: {}", total_slides / iterations);



    // =========== Single-threaded Streamed Approach ===========
    let mut single_thread_streamed_bench = Benchmark::new("Single-threaded streamed parsing");

    total_slides = 0;

    for i in 0..iterations {
        println!("\nIteration {} (Single-threaded streamed)", i + 1);

        // Measure container creation
        let mut container = single_thread_streamed_bench.measure(|| {
            let config = ParserConfig::builder()
                .extract_images(true)
                .build();
            PptxContainer::open(Path::new(pptx_path), config).expect("Failed to open PPTX")
        });

        println!("  Found {} slides in the presentation", container.slide_count);

        // Zähle die Slides im Voraus für die statistische Auswertung
        let expected_slides = container.slide_count;

        // Measure slide processing (including parsing and conversion)
        let slides_processed = single_thread_streamed_bench.measure(|| {
            let mut processed = 0;

            // Process slides one by one using the iterator
            for slide_result in container.iter_slides() {
                match slide_result {
                    Ok(slide) => {
                        // Konvertiere den Slide zu Markdown
                        let _md_content = slide.convert_to_md();
                        processed += 1;
                    },
                    Err(e) => {
                        eprintln!("Error processing slide: {:?}", e);
                    }
                }
            }

            processed
        });

        println!("  Processed {} out of {} slides", slides_processed, expected_slides);
        total_slides += slides_processed;
    }

    single_thread_streamed_bench.report();
    println!("Average slides per presentation: {}", total_slides / iterations);



    // =========== Optimized Multi-threaded Approach ===========
    let mut optimized_multi_thread_bench = Benchmark::new("Optimized Multi-threaded parsing");

    total_slides = 0;

    for i in 0..iterations {
        println!("\nIteration {} (Optimized Multi-threaded)", i + 1);

        // Container öffnen mit der gewünschten Konfiguration
        let mut container = optimized_multi_thread_bench.measure(|| {
            let config = ParserConfig::builder()
                .extract_images(true)
                .build();
            PptxContainer::open(Path::new(pptx_path), config).expect("Failed to open PPTX")
        });

        println!("  Found {} slides in the presentation", container.slide_count);

        // Verwende die neue optimierte Multi-Threading-Methode
        let slides = optimized_multi_thread_bench.measure(|| {
            container.parse_all_multi_threaded().expect("Failed to parse slides")
        });

        println!("  Successfully processed {} slides", slides.len());

        // Parallel zu Markdown konvertieren (bleibt unverändert)
        let _md_content = optimized_multi_thread_bench.measure(|| {
            slides.par_iter()
                .filter_map(|slide| slide.convert_to_md())
                .collect::<Vec<String>>()
        });

        total_slides += slides.len();
    }

    optimized_multi_thread_bench.report();
    println!("Average slides per presentation: {}", total_slides / iterations);

    // =========== Performance Comparison ===========
    if !single_thread_bench.results.is_empty() &&
        !single_thread_streamed_bench.results.is_empty() &&
        !optimized_multi_thread_bench.results.is_empty() {

        let single_avg: Duration = single_thread_bench.results.iter().sum::<Duration>() /
            single_thread_bench.results.len() as u32;
        let single_streamed_avg: Duration = single_thread_streamed_bench.results.iter().sum::<Duration>() /
            single_thread_streamed_bench.results.len() as u32;
        let optimized_multi_avg: Duration = optimized_multi_thread_bench.results.iter().sum::<Duration>() /
            optimized_multi_thread_bench.results.len() as u32;

        println!("\nPerformance Comparison");
        println!("=====================");
        println!("Single-threaded average: {:?}", single_avg);
        println!("Single-threaded streaming average: {:?}", single_streamed_avg);
        println!("Optimized multi-threaded average: {:?}", optimized_multi_avg);

        // Compare single-threaded vs single-threaded streaming
        if single_avg > single_streamed_avg {
            let speedup = single_avg.as_secs_f64() / single_streamed_avg.as_secs_f64();
            println!("Single-threaded streaming is {:.2}x faster than single-threaded", speedup);
        } else {
            let slowdown = single_streamed_avg.as_secs_f64() / single_avg.as_secs_f64();
            println!("Single-threaded streaming is {:.2}x slower than single-threaded", slowdown);
        }

        // Compare single-threaded vs optimized multithreaded
        if single_avg > optimized_multi_avg {
            let speedup = single_avg.as_secs_f64() / optimized_multi_avg.as_secs_f64();
            println!("Optimized multi-threaded is {:.2}x faster than single-threaded", speedup);
        } else {
            let slowdown = optimized_multi_avg.as_secs_f64() / single_avg.as_secs_f64();
            println!("Optimized multi-threaded is {:.2}x slower than single-threaded", slowdown);
        }

        // Compare single-threaded streaming vs optimized multithreaded
        if single_streamed_avg > optimized_multi_avg {
            let speedup = single_streamed_avg.as_secs_f64() / optimized_multi_avg.as_secs_f64();
            println!("Optimized multi-threaded is {:.2}x faster than single-threaded streaming", speedup);
        } else {
            let slowdown = optimized_multi_avg.as_secs_f64() / single_streamed_avg.as_secs_f64();
            println!("Optimized multi-threaded is {:.2}x slower than single-threaded streaming", slowdown);
        }

        // Determine the overall fastest approach
        let fastest_approach = if single_avg <= single_streamed_avg && single_avg <= optimized_multi_avg {
            "Single-threaded"
        } else if single_streamed_avg <= single_avg && single_streamed_avg <= optimized_multi_avg {
            "Single-threaded streaming"
        } else {
            "Optimized multi-threaded"
        };

        println!("\nOverall result: {} approach is the fastest for this workload.", fastest_approach);
    }

    Ok(())
}

Trait Implementations

impl Clone for ParserConfig

fn clone(&self) -> ParserConfig

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ParserConfig

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

Formats the value using the given formatter.

impl Default for ParserConfig

fn default() -> Self

Returns the “default value” for a type.