view release on metacpan or  search on metacpan

lib/PDF/Make/Linearization.pm  view on Meta::CPAN

        *PDF::Make::Document::is_linearized = sub { $_[0]->_xs_is_linearized };
    }

    # linear_params - wraps XS _xs_linear_params; returns undef when not linearized
    unless (defined &PDF::Make::Document::linear_params) {
        *PDF::Make::Document::linear_params = sub {
            my ($self) = @_;
            return undef unless $self->is_linearized;
            return $self->_xs_linear_params;
        };
    }

    # linearize - wraps XS _xs_linearize, records state for write_linearized
    unless (defined &PDF::Make::Document::linearize) {
        *PDF::Make::Document::linearize = sub {
            my ($self) = @_;
            $self->_xs_linearize;
            $_linearize_state{"$self"} = 1;
            return $self;
        };
    }

    # write_linearized - wraps XS _xs_write_linearized_to_path, or returns bytes
    unless (defined &PDF::Make::Document::write_linearized) {
        *PDF::Make::Document::write_linearized = sub {
            my ($self, $path) = @_;
            $_linearize_state{"$self"} = 1;
            return $self->_xs_write_linearized_to_path($path) if defined $path;
            return $self->_write_linearized_bytes;
        };
    }
    
    # _write_linearized_bytes - use LinearContext to produce linearized output
    unless (defined &PDF::Make::Document::_write_linearized_bytes) {
        *PDF::Make::Document::_write_linearized_bytes = sub {
            my ($self) = @_;

            # Use LinearContext pipeline
            my $ctx = PDF::Make::LinearContext->_new($self);
            $ctx->analyze;
            $ctx->build_hints;
            return $ctx->write;
        };
    }
}

=head1 PDF::Make::StreamReader

Streaming reader for linearized PDFs, enabling page-on-demand loading.

=head2 new

    my $reader = PDF::Make::StreamReader->new(
        fetch => sub {
            my ($offset, $length) = @_;
            # Return $length bytes starting at $offset
            return $data;
        }
    );

Creates a new streaming reader with the given fetch callback.

=head2 read_header

    $reader->read_header;

Reads and parses the PDF header and linearization dictionary.
This is the first operation to perform.

=head2 is_linearized

    if ($reader->is_linearized) { ... }

Returns true if the PDF is linearized.

=head2 page_count

    my $count = $reader->page_count;

Returns the total number of pages. Available after C<read_header>.

=head2 page_available

    if ($reader->page_available($page_num)) { ... }

Returns true if the given page (0-based) is loaded.

=head2 read_page

    $reader->read_page($page_num);

Fetches and parses the given page's data. May trigger HTTP range request.

=head2 page_range

    my ($offset, $length) = $reader->page_range($page_num);

Returns the byte offset and length for the given page.
Useful for HTTP Range header construction.

=cut

package PDF::Make::StreamReader;

use strict;
use warnings;
use Carp qw(croak);

sub new {
    my ($class, %args) = @_;
    
    croak "fetch callback required" unless $args{fetch};
    croak "fetch must be a code reference" unless ref($args{fetch}) eq 'CODE';
    
    my $self = bless {
        fetch           => $args{fetch},
        is_linearized   => 0,
        page_count      => 0,
        params          => {},
        hints_loaded    => 0,
        page_hints      => [],