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_number_as_comment: bool,
    pub include_speaker_notes: bool,
    pub include_comments: bool,
    pub include_presentation_metadata: 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
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_number_as_comment	bool	true	Whether the slide number comment is included (<!-- Slide [n] -->)
include_speaker_notes	bool	false	Whether speaker notes are appended to Markdown as blockquotes
include_comments	bool	false	Whether presentation comments are appended to Markdown as blockquotes
include_presentation_metadata	bool	true	Whether presentation-wide Markdown starts with a metadata comment

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_number_as_comment: bool

include_speaker_notes: bool

include_comments: bool

include_presentation_metadata: bool

Implementations

impl ParserConfig

pub fn builder() -> ParserConfigBuilder

Examples found in repository

examples/save_images.rs (line 25)

fn main() -> Result<()> {
    let args: Vec<String> = env::args().collect();
    let Some(input_path) = args.get(1) else {
        eprintln!(
            "Usage: cargo run --example save_images <presentation.pptx|presentation.odp> [image-directory] [output.md]"
        );
        return Ok(());
    };
    let image_directory = args
        .get(2)
        .map(PathBuf::from)
        .unwrap_or_else(|| PathBuf::from("extracted_images"));
    let output_path = args.get(3).map(String::as_str).unwrap_or("output.md");

    let config = ParserConfig::builder()
        .image_handling_mode(ImageHandlingMode::Save)
        .image_output_path(image_directory)
        .build();
    let mut presentation = PresentationContainer::open(Path::new(input_path), config)?;

    fs::write(output_path, presentation.convert_to_md()?)?;
    println!("Saved Markdown to {output_path}");
    Ok(())
}

examples/basic_usage.rs (line 26)

fn main() -> Result<()> {
    let args: Vec<String> = env::args().collect();
    let pptx_path = if args.len() > 1 {
        &args[1]
    } else {
        eprintln!("Usage: cargo run --example basic_usage <presentation.pptx|presentation.odp> <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
    };

    let config = ParserConfig::builder()
        .extract_images(extract_images)
        .include_presentation_metadata(true)
        .include_comments(true)
        .include_speaker_notes(true)
        .build();
    let mut container = PresentationContainer::open(Path::new(pptx_path), config)?;
    let markdown = container.convert_to_md()?;

    fs::write("output.md", markdown)?;
    println!("Converted {:?} presentation to output.md", container.format());
    Ok(())
}

examples/manual_image_extraction.rs (line 26)

fn main() -> Result<()> {
    let args: Vec<String> = env::args().collect();
    let Some(input_path) = args.get(1) else {
        eprintln!(
            "Usage: cargo run --example manual_image_extraction <presentation.pptx|presentation.odp>"
        );
        return Ok(());
    };

    println!("Processing presentation: {input_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();

    let mut container = PresentationContainer::open(Path::new(input_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)?;

    let mut image_count = 1;

    // Convert each slide to Markdown and save
    for slide in slides {
        writeln!(md_file, "{}", slide.convert_to_md()?)?;

        // 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())
                    .expect("parser returned invalid base64 image data");

                // Extract image extension if the image is not compressed, otherwise its always `.jpg`
                let ext = if slide.config.compress_images {
                    "jpg".to_string()
                } 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
                )?;

                image_count += 1;
            }
        }
    }

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

    Ok(())
}

examples/performance_test.rs (line 103)

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 <presentation.pptx|presentation.odp> [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();
            PresentationContainer::open(Path::new(pptx_path), config)
                .expect("Failed to open presentation")
        });

        // Measure parsing
        let slides =
            single_thread_bench.measure(|| container.parse_all().expect("Failed to parse slides"));
        println!("  Found {} slides in the presentation", slides.len());

        // Measure conversion
        let _md_content = single_thread_bench.measure(|| {
            slides
                .iter()
                .filter_map(|slide| slide.convert_to_md().ok())
                .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();
            PresentationContainer::open(Path::new(pptx_path), config)
                .expect("Failed to open presentation")
        });

        // 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 {} slides", slides_processed);
        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();
            PresentationContainer::open(Path::new(pptx_path), config)
                .expect("Failed to open presentation")
        });

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