use crate::json::Json;
use crate::json_inspect::{
side_file_io_error, ConvertError, DecodeLevel, JsonObjectSelector, JsonOutputError,
StreamDataMode,
};
use crate::object_handle::{ObjectHandle, QpdfStreamJsonData};
use crate::pipeline::buffer::Buffer;
use crate::pipeline::stdio_file::StdioBuffer;
use crate::pipeline::{Pipeline, PlStdioFile};
use crate::ObjectRef;
use crate::Pdf;
use std::fs::File;
use std::io::{Read, Seek, Write};
const SUPPORTED_JSON_VERSION: i32 = 2;
pub(crate) fn write_json_v1_objects_key<R: Read + Seek>(
pdf: &mut Pdf<R>,
out: &mut dyn Pipeline,
first: &mut bool,
wanted_objects: &[JsonObjectSelector],
) -> Result<(), JsonOutputError> {
Json::write_dictionary_key(out, first, b"objects", 1)?;
let mut object_first = true;
Json::write_dictionary_open(out, &mut object_first, 1)?;
for handle in pdf.get_all_objects().map_err(ConvertError::from)? {
let object_ref = handle
.object_ref()
.expect("qpdf object-map entries are indirect handles");
if !object_selected(wanted_objects, object_ref) {
continue;
}
let key = format!("{} {} R", object_ref.number, object_ref.generation);
Json::write_dictionary_key(out, &mut object_first, key.as_bytes(), 2)?;
handle.write_json(1, out, true, 2)?;
}
if trailer_selected(wanted_objects) {
Json::write_dictionary_key(out, &mut object_first, b"trailer", 2)?;
pdf.trailer().write_json(1, out, true, 2)?; } Json::write_dictionary_close(out, object_first, 1)?;
Ok(())
}
pub(crate) fn write_json_v1_objectinfo_key<R: Read + Seek>(
pdf: &mut Pdf<R>,
out: &mut dyn Pipeline,
first: &mut bool,
wanted_objects: &[JsonObjectSelector],
) -> Result<(), JsonOutputError> {
Json::write_dictionary_key(out, first, b"objectinfo", 1)?;
let mut object_first = true;
Json::write_dictionary_open(out, &mut object_first, 1)?;
for handle in pdf.get_all_objects().map_err(ConvertError::from)? {
let object_ref = handle
.object_ref()
.expect("qpdf object-map entries are indirect handles");
if !object_selected(wanted_objects, object_ref) {
continue;
}
let resolved = handle.clone();
pdf.resolve(&resolved).map_err(ConvertError::from)?;
let (is_stream, filter, length) = if let Some(stream_dict) = resolved
.as_stream_dict()
.and_then(|dict| dict.as_dictionary())
{
let filter = stream_dict
.get(b"/Filter".as_slice())
.cloned()
.unwrap_or_else(ObjectHandle::null);
let length = stream_dict
.get(b"/Length".as_slice())
.cloned()
.unwrap_or_else(ObjectHandle::null);
(true, filter, length)
} else {
(false, ObjectHandle::null(), ObjectHandle::null())
};
let key = format!("{} {} R", object_ref.number, object_ref.generation);
Json::write_dictionary_key(out, &mut object_first, key.as_bytes(), 2)?;
let mut details_first = true;
Json::write_dictionary_open(out, &mut details_first, 2)?;
Json::write_dictionary_key(out, &mut details_first, b"stream", 3)?;
let mut stream_first = true;
Json::write_dictionary_open(out, &mut stream_first, 3)?;
Json::write_dictionary_key(out, &mut stream_first, b"filter", 4)?;
filter.write_json(1, out, true, 4)?;
Json::write_dictionary_item(
out,
&mut stream_first,
b"is",
&Json::make_bool(is_stream),
4,
)?; Json::write_dictionary_key(out, &mut stream_first, b"length", 4)?;
length.write_json(1, out, true, 4)?;
Json::write_dictionary_close(out, stream_first, 3)?;
Json::write_dictionary_close(out, details_first, 2)?;
}
Json::write_dictionary_close(out, object_first, 1)?;
Ok(())
}
pub fn format_json_side_file_path(prefix: &str, obj_num: u32) -> String {
format!("{prefix}-{obj_num}")
}
pub fn write_json<R: Read + Seek>(
pdf: &mut Pdf<R>,
version: i32,
out: &mut dyn Pipeline,
decode_level: DecodeLevel,
stream_mode: &StreamDataMode,
wanted_objects: &[JsonObjectSelector],
) -> Result<(), JsonOutputError> {
let mut first_key = true;
write_json_key(
pdf,
version,
out,
true,
&mut first_key,
decode_level,
stream_mode,
wanted_objects,
)
}
#[allow(clippy::too_many_arguments)]
pub fn write_json_key<R: Read + Seek>(
pdf: &mut Pdf<R>,
version: i32,
out: &mut dyn Pipeline,
complete: bool,
first_key: &mut bool,
decode_level: DecodeLevel,
stream_mode: &StreamDataMode,
wanted_objects: &[JsonObjectSelector],
) -> Result<(), JsonOutputError> {
if version != SUPPORTED_JSON_VERSION {
return Err(JsonOutputError::UnsupportedVersion);
}
if complete {
Json::write_dictionary_open(out, first_key, 0)?;
}
Json::write_dictionary_key(out, first_key, b"qpdf", 1)?;
let mut qpdf_first = true;
Json::write_array_open(out, &mut qpdf_first, 1)?;
Json::write_next(out, &mut qpdf_first, 2)?;
let mut metadata_first = true;
Json::write_dictionary_open(out, &mut metadata_first, 2)?;
Json::write_dictionary_item(
out,
&mut metadata_first,
b"jsonversion",
&Json::make_int(i64::from(version)),
3,
)?;
Json::write_dictionary_item(
out,
&mut metadata_first,
b"pdfversion",
&Json::make_string(pdf.version()),
3,
)?;
Json::write_dictionary_item(
out,
&mut metadata_first,
b"pushedinheritedpageresources",
&Json::make_bool(false),
3,
)?;
Json::write_dictionary_item(
out,
&mut metadata_first,
b"calledgetallpages",
&Json::make_bool(pdf.ever_called_get_all_pages()),
3,
)?;
Json::write_dictionary_key(out, &mut metadata_first, b"maxobjectid", 3)?;
let max_object_id = pdf.get_object_count().map_err(ConvertError::from)?;
Json::make_int(i64::from(max_object_id)).write(out, 3)?;
Json::write_dictionary_close(out, metadata_first, 2)?;
Json::write_next(out, &mut qpdf_first, 2)?;
let mut objects_first = true;
Json::write_dictionary_open(out, &mut objects_first, 2)?;
let objects = pdf.get_all_objects().map_err(ConvertError::from)?;
for handle in objects {
let object_ref = handle
.object_ref()
.expect("qpdf object-map entries are indirect handles");
if !object_selected(wanted_objects, object_ref) {
continue;
}
let result = match stream_mode {
StreamDataMode::None => write_non_file_mode_object_entry(
pdf,
&handle,
decode_level,
QpdfStreamJsonData::None,
out,
&mut objects_first,
),
StreamDataMode::Inline => write_non_file_mode_object_entry(
pdf,
&handle,
decode_level,
QpdfStreamJsonData::Inline,
out,
&mut objects_first,
),
StreamDataMode::File { prefix } => write_file_mode_object_entry(
pdf,
&handle,
decode_level,
prefix,
out,
&mut objects_first,
),
};
result?;
}
if trailer_selected(wanted_objects) {
let trailer = pdf.trailer();
Json::write_dictionary_key(out, &mut objects_first, b"trailer", 3)?;
let mut trailer_first = true;
Json::write_dictionary_open(out, &mut trailer_first, 3)?;
Json::write_dictionary_key(out, &mut trailer_first, b"value", 4)?;
trailer.write_json(SUPPORTED_JSON_VERSION, out, true, 4)?;
Json::write_dictionary_close(out, trailer_first, 3)?;
}
Json::write_dictionary_close(out, false, 2)?;
Json::write_array_close(out, qpdf_first, 1)?;
if complete {
Json::write_dictionary_close(out, false, 0)?;
out.write(b"\n")?;
out.finish()?;
}
Ok(())
}
fn object_selected(selectors: &[JsonObjectSelector], object_ref: ObjectRef) -> bool {
selectors.is_empty()
|| selectors.iter().any(|selector| {
matches!(
selector,
JsonObjectSelector::Object { number, generation }
if *number == object_ref.number
&& *generation == object_ref.generation
)
})
}
fn trailer_selected(selectors: &[JsonObjectSelector]) -> bool {
selectors.is_empty()
|| selectors
.iter()
.any(|selector| matches!(selector, JsonObjectSelector::Trailer))
}
fn stream_decode_level(level: DecodeLevel) -> crate::writer::DecodeLevel {
match level {
DecodeLevel::None => crate::writer::DecodeLevel::None,
DecodeLevel::Generalized => crate::writer::DecodeLevel::Generalized,
DecodeLevel::Specialized => crate::writer::DecodeLevel::Specialized,
DecodeLevel::All => crate::writer::DecodeLevel::All,
}
}
fn write_non_file_mode_object_entry<R: Read + Seek>(
pdf: &mut Pdf<R>,
handle: &ObjectHandle,
decode_level: DecodeLevel,
stream_mode: QpdfStreamJsonData,
out: &mut dyn Pipeline,
objects_first: &mut bool,
) -> Result<(), JsonOutputError> {
let object_ref = handle
.object_ref()
.expect("qpdf object-map entries are indirect handles");
let key = format!("obj:{} {} R", object_ref.number, object_ref.generation);
let handle = pdf.resolve_handle(handle).map_err(ConvertError::from)?;
if handle.type_code().map_err(ConvertError::from)? == 10 {
let mut stream_value = Buffer::new("stream JSON", None);
handle.write_stream_json(
SUPPORTED_JSON_VERSION,
&mut stream_value,
stream_mode,
stream_decode_level(decode_level),
None,
"",
false,
4,
)?;
stream_value.finish()?;
let stream_value = stream_value.take_buffer()?;
Json::write_dictionary_key(out, objects_first, key.as_bytes(), 3)?;
let mut object_first = true;
Json::write_dictionary_open(out, &mut object_first, 3)?;
Json::write_dictionary_key(out, &mut object_first, b"stream", 4)?;
out.write(&stream_value)?;
Json::write_dictionary_close(out, object_first, 3)?;
return Ok(());
}
write_non_stream_value_entry(&handle, key.as_bytes(), out, objects_first)?;
Ok(())
}
fn write_file_mode_object_entry<R: Read + Seek>(
pdf: &mut Pdf<R>,
handle: &ObjectHandle,
decode_level: DecodeLevel,
prefix: &str,
out: &mut dyn Pipeline,
objects_first: &mut bool,
) -> Result<(), JsonOutputError> {
let object_ref = handle
.object_ref()
.expect("qpdf object-map entries are indirect handles");
let key = format!("obj:{} {} R", object_ref.number, object_ref.generation);
let handle = pdf.resolve_handle(handle).map_err(ConvertError::from)?;
if handle.type_code().map_err(ConvertError::from)? == 10 {
Json::write_dictionary_key(out, objects_first, key.as_bytes(), 3)?;
let mut object_first = true;
Json::write_dictionary_open(out, &mut object_first, 3)?;
Json::write_dictionary_key(out, &mut object_first, b"stream", 4)?;
let side_path = format_json_side_file_path(prefix, object_ref.number);
let mut side_file = File::create(&side_path)
.map_err(|source| side_file_io_error("open", &side_path, source))?;
write_json_stream_file(&handle, decode_level, &side_path, &mut side_file, out)?;
Json::write_dictionary_close(out, object_first, 3)?;
return Ok(());
}
write_non_stream_value_entry(&handle, key.as_bytes(), out, objects_first)?;
Ok(())
}
fn write_non_stream_value_entry(
handle: &ObjectHandle,
key: &[u8],
out: &mut dyn Pipeline,
objects_first: &mut bool,
) -> Result<(), JsonOutputError> {
Json::write_dictionary_key(out, objects_first, key, 3)?;
let mut object_first = true;
Json::write_dictionary_open(out, &mut object_first, 3)?;
Json::write_dictionary_key(out, &mut object_first, b"value", 4)?;
handle.write_json(SUPPORTED_JSON_VERSION, out, true, 4)?;
Json::write_dictionary_close(out, object_first, 3)?;
Ok(())
}
pub(crate) fn write_json_stream_file(
handle: &ObjectHandle,
decode_level: DecodeLevel,
side_path: &str,
side_file: &mut dyn Write,
out: &mut dyn Pipeline,
) -> Result<(), JsonOutputError> {
let mut buffered = StdioBuffer::new(side_file);
let mut terminal = PlStdioFile::new("stream data", &mut buffered);
handle.write_stream_json(
SUPPORTED_JSON_VERSION,
out,
QpdfStreamJsonData::File,
stream_decode_level(decode_level),
Some(&mut terminal),
side_path,
false,
4,
)?;
terminal.finish()?;
Ok(())
}