/* =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- */

/* EXIFPROBE - TIFF/JPEG/EXIF image file probe */

/* =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- */

/* Copyright (C) 2002,2005 by Duane H. Hesser. All rights reserved. */

/* */

/* See the file LICENSE.EXIFPROBE for terms of use. */

/* =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- */

#ifndef lint

static char *ModuleId = "@(#) $Id: print_maker.c,v 1.29 2005/07/24 17:27:09 alex Exp $";

#endif

#include <stdio.h>

#include <string.h>

#include "defs.h"

#include "summary.h"

#include "maker.h"

#include "datadefs.h"

#include "maker_datadefs.h"

#include "misc.h"

#include "tags.h"

#include "maker_extern.h"

#include "extern.h"

extern struct camera_name Camera_make[];

#ifndef STRCASESTR

#define STRCASESTR fake_strcasestr

extern char *fake_strcasestr(char *,char *);

#endif

/* Print an IFD entry presumed to be from a MakerNote. */

/* This differs from print_entry() in that it dispatches */

/* maker_tagname() to get tag names specific to a specific make and */

/* (possibly) model, and calls print_makervalue() to intercept any */

/* tags which may require special treatment due to maker oddities. */

/* The maker-specific routines dispatched by print_makervalue() will */

/* also handle interpretation of the tag values if known. */

unsigned long

print_makerentry(FILE *inptr,unsigned short byteorder,

struct ifd_entry *entry_ptr,unsigned long fileoffset_base,

struct image_summary *summary_entry,char *parent_name,

int indent,int make,int model)

{

int value_is_offset = 0;

unsigned long endoffset = 0UL;

int chpr = 0;

value_is_offset = is_offset(entry_ptr);

if(value_is_offset == 0)

value_is_offset = maker_value_is_offset(entry_ptr,make,model);

else

value_is_offset += maker_value_is_offset(entry_ptr,make,model);

if(PRINT_ENTRY)

print_makertaginfo(entry_ptr,parent_name,indent,make,model);

if((entry_ptr->value_type == 0) || (entry_ptr->value_type > DOUBLE))

{

if(PRINT_ENTRY)

chpr = printf("# INVALID MAKERNOTE ENTRY (%#lx)",entry_ptr->value);

endoffset = ftell(inptr);

}

else if(entry_ptr->count == 0)

{

if(PRINT_VALUE)

chpr = printf("EMPTY (%lu)",entry_ptr->value);

endoffset = ftell(inptr);

}

else if(value_is_offset)

{

if(value_is_offset > 0)

{

if(PRINT_BOTH_OFFSET)

chpr += printf("@%#lx=%lu",entry_ptr->value + fileoffset_base,

entry_ptr->value + fileoffset_base);

else if(PRINT_HEX_OFFSET)

chpr += printf("@%#lx",entry_ptr->value + fileoffset_base);

else if(PRINT_DEC_OFFSET)

chpr += printf("@%lu",entry_ptr->value + fileoffset_base);

if(fileoffset_base && (PRINT_ENTRY_RELOFFSET))

chpr += printf(" (%lu)",entry_ptr->value);

}

else if((value_is_offset < 0) && (PRINT_VALUE))

print_makervalue(entry_ptr,make,model,PREFIX);

/* Print "inline" in REPORT & LIST modes */

if(!(PRINT_VALUE_AT_OFFSET))

{

setcharsprinted(chpr);

chpr = 0;

endoffset = print_offset_makervalue(inptr,byteorder,

entry_ptr,fileoffset_base,

summary_entry,parent_name,

"@",indent + SUBINDENT,

make,model,0);

}

}

else if(PRINT_VALUE)

print_makervalue(entry_ptr,make,model,PREFIX);

chpr = newline(chpr);

return(endoffset);

}

/* Repeat the tag identifier for values printed at an offset. This is */

/* called only from the "*makervalue-at_offset()" routines when */

/* printing offset values at the offset (rather than "inline"), and */

/* repeats only one of the identifiers (preferably tagname) followed */

/* by the value separator (if values are printed at all). If no tag */

/* identifier is enabled in Print_options, the tag name will be */

/* printed, as in the entry line printed by print_makertaginfo(). */

/* The caller will normally pass the 'sep' argument as ' = ' if an */

/* actual value is to follow, or ': ' if a description (e.g. length */

/* of UNDEFINED segment which is not expanded). */

void

print_makertagid(struct ifd_entry *entry_ptr,int width, char *sep,

int make,int model)

{

char *nameoftag;

int chpr = 0;

if(entry_ptr)

{

if((PRINT_TAGNAME))

{

nameoftag = maker_tagname(entry_ptr->tag,make,model);

chpr = printf("%-*.*s",width,width,nameoftag);

}

else if(PRINT_HEX_TAGNO)

chpr = printf("<%#06x>",entry_ptr->tag & 0xffff);

else if(PRINT_DEC_TAGNO)

chpr = printf("<%5u>",entry_ptr->tag & 0xffff);

if(PRINT_VALUE)

chpr += printf("%s",sep ? sep : " = ");

}

setcharsprinted(chpr);

}

/* Print the part of a MakerNote entry describing the entry tag, */

/* including it's tag number, name and type. Only the items enabled */

/* in "Print_options" are printed. */

/* In LIST mode prefix the tag name with a section identifier, so */

/* that the resulting names may be recognized by patterns or regular */

/* expressions applied to the output (e.g. 'egrep') in */

/* post-processing. */

void

print_makertaginfo(struct ifd_entry *entry_ptr,char *parent_name,

int indent,int make,int model)

{

char *nameoftag;

char *nameof_value_type;

int chpr = 0;

if(entry_ptr)

{

if(PRINT_BOTH_TAGNO)

chpr = printf("<%#06X=%5u> ",entry_ptr->tag & 0xffff,entry_ptr->tag & 0xffff);

else if(PRINT_HEX_TAGNO)

chpr = printf("<%#06X> ",entry_ptr->tag & 0xffff);

else if(PRINT_DEC_TAGNO)

chpr = printf("<%5u> ",entry_ptr->tag & 0xffff);

if((PRINT_TAGNAME))

{

nameoftag = maker_tagname(entry_ptr->tag,make,model);

if((PRINT_LONGNAMES))

chpr += printf("%s.",parent_name);

chpr += printf("%-*.*s",MAKERTAGWIDTH,MAKERTAGWIDTH,nameoftag);

}

if(PRINT_TYPE)

{

nameof_value_type = value_type_name(entry_ptr->value_type);

chpr += printf(" [%2u=%-9.9s %5lu] ",entry_ptr->value_type,

nameof_value_type,entry_ptr->count);

}

if(Debug & NOTE_DEBUG)

{

chpr += printf(" %d:%d,%d ",model,getnoteversion(),getnotetagset());

}

if(PRINT_VALUE)

chpr += printf(" = ");

}

setcharsprinted(chpr);

}

/* Dispatch maker-specific routines to print (and possibly interpret) */

/* non-offset values in MakerNote IFDs. If the make is not known, the */

/* normal print_value() routine will be called, and the */

/* maker-specific routines are free to do the same if the tag doesn't */

/* need special handling (such as a 4 byte UNDEFINED which should be */

/* printed as ascii). The maker-specific routines can also call */

/* routines to interpret the value (e.g "On", "Off", etc.) according */

/* to the requirements of the make and model. */

void

print_makervalue(struct ifd_entry *entry_ptr,int make,int model,char *prefix)

{

if(entry_ptr)

{

switch(make)

{

case MAKER_AGFA:

print_agfa_makervalue(entry_ptr,make,model,PREFIX);

break;

case MAKER_ASAHI: /* Asahi is Pentax */

case MAKER_PENTAX: /* Pentax is Asahi */

print_asahi_makervalue(entry_ptr,make,model,PREFIX);

break;

case MAKER_CANON:

print_canon_makervalue(entry_ptr,make,model,PREFIX);

break;

case MAKER_CASIO:

print_casio_makervalue(entry_ptr,make,model,PREFIX);

break;

case MAKER_EPSON:

print_epson_makervalue(entry_ptr,make,model,PREFIX);

break;

case MAKER_FUJIFILM:

print_fujifilm_makervalue(entry_ptr,make,model,PREFIX);

break;

case MAKER_HP:

print_value(entry_ptr,PREFIX);

break;

case MAKER_KODAK:

print_value(entry_ptr,PREFIX);

break;

case MAKER_KONICA:

print_konica_makervalue(entry_ptr,make,model,PREFIX);

break;

case MAKER_KYOCERA:

print_kyocera_makervalue(entry_ptr,make,model,PREFIX);

break;

case MAKER_LEICA:

print_leica_makervalue(entry_ptr,make,model,PREFIX);

break;

case MAKER_MINOLTA:

print_minolta_makervalue(entry_ptr,make,model,PREFIX);

break;

case MAKER_NIKON:

print_nikon_makervalue(entry_ptr,make,model,PREFIX);

break;

case MAKER_OLYMPUS:

print_olympus_makervalue(entry_ptr,make,model,PREFIX);

break;

case MAKER_PANASONIC:

print_panasonic_makervalue(entry_ptr,make,model,PREFIX);

break;

case MAKER_RICOH:

print_value(entry_ptr,PREFIX);

break;

case MAKER_SANYO:

print_sanyo_makervalue(entry_ptr,make,model,PREFIX);

break;

case MAKER_SIGMA:

print_sigma_makervalue(entry_ptr,make,model,PREFIX);

break;

case MAKER_SONY:

print_sony_makervalue(entry_ptr,make,model,PREFIX);

break;

case MAKER_TOSHIBA:

print_toshiba_makervalue(entry_ptr,make,model,PREFIX);

break;

case MAKER_TRAVELER:

print_value(entry_ptr,PREFIX);

break;

default: /* No maker_specific print routine available */

print_value(entry_ptr,PREFIX); /* use default` */

break;

}

}

}

/* Print values found at offsets in a MakerNote entry by dispatching */

/* maker-specific routines which know how to interpret UNDEFINED */

/* values for that maker. These routines may also intercept "defined" */

/* values which are handled strangely, such as a "long" value which */

/* is really an offset, or a 4-byte UNDEFINED value which is really */

/* an offset to an UNDEFINED blob. If a maker-specific routine is */

/* called, it must handle all values for that maker (possibly by */

/* calling the generic routine). The generic and maker-specific */

/* routines are all 'void' functions, which should assure that the */

/* file pointer is moved past the subject data. This routine */

/* clears any IO errors (or EOF) and returns the calculated file */

/* offset of the end of the section. */

unsigned long

print_offset_makervalue(FILE *inptr,unsigned short byteorder,

struct ifd_entry *entry_ptr,unsigned long fileoffset_base,

struct image_summary *summary_entry,char *parent_name,char*prefix,

int indent,int make,int model,int at_offset)

{

unsigned long endoffset = 0L;

if(inptr && entry_ptr)

{

if((value_type_size(entry_ptr->value_type) * entry_ptr->count) <= 4UL)

endoffset = 0;

else

endoffset = fileoffset_base + entry_ptr->value +

(value_type_size(entry_ptr->value_type) * entry_ptr->count);

switch(make)

{

case MAKER_AGFA:

print_agfa_offset_makervalue(inptr,byteorder,entry_ptr,

fileoffset_base,summary_entry,

parent_name,prefix,indent,make,

model,at_offset);

break;

case MAKER_ASAHI: /* Pentax */

case MAKER_PENTAX: /* Pentax */

print_asahi_offset_makervalue(inptr,byteorder,entry_ptr,

fileoffset_base,summary_entry,

parent_name,prefix,indent,make,

model,at_offset);

break;

case MAKER_CANON:

print_canon_offset_makervalue(inptr,byteorder,entry_ptr,

fileoffset_base,summary_entry,

parent_name,prefix,indent,make,

model,at_offset);

break;

case MAKER_CASIO:

print_casio_offset_makervalue(inptr,byteorder,entry_ptr,

fileoffset_base,summary_entry,

parent_name,prefix,indent,make,

model,at_offset);

break;

case MAKER_EPSON:

print_epson_offset_makervalue(inptr,byteorder,entry_ptr,

fileoffset_base,summary_entry,

parent_name,prefix,indent,make,

model,at_offset);

break;

case MAKER_FUJIFILM:

print_fujifilm_offset_makervalue(inptr,byteorder,entry_ptr,

fileoffset_base,summary_entry,

parent_name,prefix,indent,

make,model,at_offset);

break;

case MAKER_HP:

print_generic_offset_makervalue(inptr,byteorder,entry_ptr,

fileoffset_base,parent_name,prefix,indent,

make,model,at_offset);

break;

case MAKER_KODAK:

print_generic_offset_makervalue(inptr,byteorder,entry_ptr,

fileoffset_base,parent_name,prefix,indent,

make,model,at_offset);

break;

case MAKER_KYOCERA:

print_kyocera_offset_makervalue(inptr,byteorder,entry_ptr,

fileoffset_base,summary_entry,

parent_name,prefix,indent,

make,model,at_offset);

break;

case MAKER_KONICA:

print_konica_offset_makervalue(inptr,byteorder,entry_ptr,

fileoffset_base,summary_entry,

parent_name,prefix,indent,

make,model,at_offset);

break;

case MAKER_LEICA:

print_leica_offset_makervalue(inptr,byteorder,entry_ptr,

fileoffset_base,summary_entry,

parent_name,prefix,indent,

make,model,at_offset);

break;

case MAKER_MINOLTA:

print_minolta_offset_makervalue(inptr,byteorder,entry_ptr,

fileoffset_base,summary_entry,

parent_name,prefix,indent,make,

model,at_offset);

break;

case MAKER_NIKON:

print_nikon_offset_makervalue(inptr,byteorder,entry_ptr,

fileoffset_base,summary_entry,

parent_name,prefix,indent,make,

model,at_offset);

break;

case MAKER_OLYMPUS:

print_olympus_offset_makervalue(inptr,byteorder,entry_ptr,

fileoffset_base,summary_entry,

parent_name,prefix,indent,make,

model,at_offset);

break;

case MAKER_PANASONIC:

print_panasonic_offset_makervalue(inptr,byteorder,entry_ptr,

fileoffset_base,summary_entry,

parent_name,prefix,indent,

make,model,at_offset);

break;

case MAKER_RICOH:

print_generic_offset_makervalue(inptr,byteorder,entry_ptr,

fileoffset_base,parent_name,prefix,indent,

make,model,at_offset);

break;

case MAKER_SANYO:

print_sanyo_offset_makervalue(inptr,byteorder,entry_ptr,

fileoffset_base,summary_entry,

parent_name,prefix,indent,make,

model,at_offset);

break;

case MAKER_SIGMA:

print_sigma_offset_makervalue(inptr,byteorder,entry_ptr,

fileoffset_base,summary_entry,

parent_name,prefix,indent,

make,model,at_offset);

break;

case MAKER_SONY:

print_sony_offset_makervalue(inptr,byteorder,entry_ptr,

fileoffset_base,summary_entry,

parent_name,prefix,indent,

make,model,at_offset);

break;

case MAKER_TOSHIBA:

print_toshiba_offset_makervalue(inptr,byteorder,entry_ptr,

fileoffset_base,summary_entry,

parent_name,prefix,indent,

make,model,at_offset);

break;

case MAKER_TRAVELER:

print_generic_offset_makervalue(inptr,byteorder,entry_ptr,

fileoffset_base,parent_name,prefix,indent,

make,model,at_offset);

break;

default:

print_generic_offset_makervalue(inptr,byteorder,entry_ptr,

fileoffset_base,parent_name,prefix,indent,

make,model,at_offset);

break;

}

}

else

{

printred(" invalid call to print_offset_makervalue ");

if(inptr == (FILE *)0)

printred(" no input file pointer ");

if(entry_ptr == (struct ifd_entry *)0)

printred(" null entry pointer");

}

if(ferror(inptr) || feof(inptr))

clearerr(inptr);

(void)newline(0);

if(ftell(inptr) > endoffset)

endoffset = ftell(inptr);

return(endoffset);

}

/* Print the value found at an offset in a generic MakerNote, if no */

/* maker-specific routine wants to deal with it. Similar to */

/* print_offset_value(). The routine is expected to read or skip all */

/* data associated with the entry. */

void

print_generic_offset_makervalue(FILE *inptr,unsigned short byteorder,

struct ifd_entry *entry_ptr,unsigned long fileoffset_base,char *parent_name,

char *prefix,int indent,int make,int model,int at_offset)

{

unsigned long value_offset;

unsigned long dumplength;

int chpr = 0;

if((value_type_size(entry_ptr->value_type) * entry_ptr->count) > 4)

{

value_offset = fileoffset_base + entry_ptr->value;

if(PRINT_VALUE)

{

if(at_offset)

{

print_tag_address(ENTRY,value_offset,indent,prefix);

if(entry_ptr->value_type == UNDEFINED)

print_makertagid(entry_ptr,MAKERTAGWIDTH," : ",make,model);

else

print_makertagid(entry_ptr,MAKERTAGWIDTH," = ",make,model);

}

else

{

if((PRINT_OFFSET) && (entry_ptr->value_type != UNDEFINED))

chpr += printf(" = ");

}

switch(entry_ptr->value_type)

{

case UNDEFINED:

/* Could make a pseudo-tag for 'count' in LIST */

/* mode... */

if((PRINT_SECTION) && at_offset && (PRINT_VALUE_AT_OFFSET))

chpr += printf("length %-9lu # UNDEFINED",entry_ptr->count);

else

{

if(!(PRINT_OFFSET))

chpr += printf("@%lu",value_offset);

chpr += printf(":%-9lu # UNDEFINED",entry_ptr->count);

}

if(Max_undefined == 0)

{

if((PRINT_SECTION))

printred(" (not dumped, use -U)");

}

else

{

/* Even in LIST and REPORT modes */

if((Max_undefined == DUMPALL)

|| (Max_undefined > entry_ptr->count))

dumplength = entry_ptr->count;

else

dumplength = Max_undefined;

chpr = newline(1);

hexdump(inptr,entry_ptr->value + fileoffset_base,

entry_ptr->count,dumplength,12,

indent,SUBINDENT);

}

/* make certain we're at the end */

fseek(inptr,entry_ptr->value + fileoffset_base + entry_ptr->count,SEEK_SET);

break;

case ASCII:

print_ascii(inptr,entry_ptr->count,value_offset);

break;

case BYTE:

print_ubytes(inptr,entry_ptr->count,value_offset);

break;

case SBYTE:

print_sbytes(inptr,entry_ptr->count,value_offset);

break;

case SHORT:

print_ushort(inptr,entry_ptr->count,byteorder,value_offset);

break;

case SSHORT:

print_sshort(inptr,entry_ptr->count,byteorder,value_offset);

break;

case LONG:

print_ulong(inptr,entry_ptr->count,byteorder,value_offset);

break;

case SLONG:

print_slong(inptr,entry_ptr->count,byteorder,value_offset);

break;

case RATIONAL:

print_urational(inptr,entry_ptr->count,byteorder,value_offset);

break;

case SRATIONAL:

print_srational(inptr,entry_ptr->count,byteorder,value_offset);

break;

case FLOAT:

print_float(inptr,entry_ptr->count,byteorder,value_offset);

break;

case DOUBLE:

print_double(inptr,entry_ptr->count,byteorder,value_offset);

break;

default:

chpr = printf(" INVALID TYPE %#x",entry_ptr->value_type);

break;

}

}

}

if(ferror(inptr) || feof(inptr))

clearerr(inptr);

setcharsprinted(chpr);

}

void

print_scheme(FILE *inptr,struct maker_scheme *maker_scheme)

{

int chpr = 0;

PUSHCOLOR(HI_BLACK);

chpr = newline(1);

chpr += printf("MakerNote Scheme:");

chpr += printf(" (at offset %lu, length %lu)",maker_scheme->note_fileoffset,

maker_scheme->note_length);

chpr = newline(chpr);

chpr += printf("\tScheme Type = ");

switch(maker_scheme->scheme_type)

{

case PLAIN_IFD_SCHEME:

chpr += printf("\"Plain IFD\" (%#lx) at offset %lu",maker_scheme->scheme_type,

maker_scheme->note_fileoffset);

chpr = newline(chpr);

break;

case HAS_ID_SCHEME:

chpr += printf("\"ID\" (%#lx)\n",maker_scheme->scheme_type);

chpr += printf("\tID = \"%s\";",maker_scheme->id[0] ? maker_scheme->id : "(NONE)");

chpr += printf(" length = %d, at offset %lu\n",maker_scheme->id_length,

maker_scheme->note_fileoffset);

chpr += printf("\tIFD is offset %d from start of section",maker_scheme->ifd_offset);

chpr = newline(chpr);

break;

case HAS_ID_PLUS_TIFFHDR_SCHEME:

chpr += printf("\"ID plus TIFF header\" (%#lx)\n",maker_scheme->scheme_type);

chpr += printf("\tID = \"%s\";",maker_scheme->id[0] ? maker_scheme->id : "(NONE)");

chpr += printf("\tlength = %d, at offset %lu\n",maker_scheme->id_length,

maker_scheme->note_fileoffset);

chpr += printf("\tTIFF header is offset %d from start of section\n",maker_scheme->tiffhdr_offset);

chpr += printf("\tIFD is offset %d from start of TIFF header",maker_scheme->ifd_offset);

chpr = newline(chpr);

break;

case UNKNOWN_SCHEME:

default:

chpr += printf("\"UNKNOWN\" (%#lx)\n",maker_scheme->scheme_type);

chpr += printf("\tID = \"%s\";",maker_scheme->id[0] ? maker_scheme->id : "(NONE)");

chpr += printf(" length = %d, at offset %lu",maker_scheme->id_length,

maker_scheme->note_fileoffset);

chpr = newline(chpr);

break;

}

if(maker_scheme->note_byteorder &&

(maker_scheme->note_byteorder != maker_scheme->tiff_byteorder))

PUSHCOLOR(HI_RED);

chpr += printf("\tNote byteorder = ");

print_byteorder(maker_scheme->note_byteorder,2);

if(maker_scheme->note_byteorder &&

(maker_scheme->note_byteorder != maker_scheme->tiff_byteorder))

{

chpr += printf(" != ");

POPCOLOR();

}

else

{

chpr = newline(chpr);

chpr += printf("\t");

}

chpr += printf("Tiff byteorder = ");

print_byteorder(maker_scheme->tiff_byteorder,2);

chpr += newline(chpr);

switch(maker_scheme->offsets_relative_to)

{

case START_OF_TIFFHEADER:

chpr += printf("\tOffsets relative to TIFF header at offset %lu",

maker_scheme->fileoffset_base);

chpr = newline(chpr);

break;

case START_OF_NOTE:

PUSHCOLOR(HI_RED);

chpr += printf("\tOffsets relative to start of MakerNote");

POPCOLOR();

chpr += printf(" at offset %lu",maker_scheme->note_fileoffset);

chpr += newline(1);

break;

case START_OF_ENTRY:

PUSHCOLOR(HI_RED);

chpr += printf("\tOffsets relative to start of entry");

POPCOLOR();

chpr += newline(1);

break;

default: chpr += printf("(UNKNOWN)\n");

break;

}

chpr += printf("\tNumber of entries = %d",maker_scheme->num_entries);

chpr = newline(chpr);

if((maker_scheme->scheme_type != UNKNOWN_SCHEME) && maker_scheme->no_nextifd_offset)

{

putchar('\t'); ++chpr;

PUSHCOLOR(HI_RED);

chpr += printf("No next IFD offset");

POPCOLOR();

chpr += newline(1);

}

if(Make_name)

{

putchar('\t'); ++chpr;

chpr += printf("Make = \"%s\"",Make_name);

chpr += printf(" (maker id = %d)",maker_scheme->make);

chpr = newline(1);

}

if(Model_name)

{

putchar('\t'); ++chpr;

chpr += printf("Model = \"%s\"",Model_name);

chpr += printf(" (model id = %d)",maker_scheme->model);

chpr = newline(1);

}

if(Software_name)

{

putchar('\t'); ++chpr;

chpr += printf("Software = \"%s\"",Software_name);

chpr = newline(1);

}

putchar('\t'); ++chpr;

chpr += printf("Note version = %d (tagset = %d)",maker_scheme->note_version,maker_scheme->tagset);

POPCOLOR();

chpr = newline(chpr);

chpr = newline(1);

}

/* Print a list of camera makes known to the program. If a global */

/* matching pattern has been set for names (by option) , limit the */

/* output to camera names for which a case-insensitive substring */

/* match occurs, otherwise list all makes. For each make printed, */

/* print the list of recognized models. The Make and Model names (in */

/* the camera_names.h and "maker"_datadefs.h files) are. or should */

/* be, the "official" names used by the maker in the Make and Model */

/* entries of and TIFF IFD or CIFF Make/Model entry. */

void

print_camera_makes()

{

struct camera_name *maker_id;

char *pattern,*model_pattern;

int chpr = 0;

chpr = newline(0);

chpr += printf("Camera Makes:");

chpr = newline(chpr);

if(Camera_name_pattern)

{

pattern = Camera_name_pattern;

if((model_pattern = strchr(pattern,'+')))

*model_pattern++ = '\0';

else

model_pattern = NULL;

/* 'Camera_make' is a global parameter */

for(maker_id = Camera_make; maker_id && maker_id->name; ++maker_id)

{

if(pattern)

{

if(*pattern == '-')

{

chpr += printf("\t%-32.32s [%d]",maker_id->name,maker_id->id);

chpr = newline(chpr);

}

else

{

if((*pattern) && !STRCASESTR(maker_id->name,pattern))

continue;

chpr += printf("\t%-32.32s [%d]",maker_id->name,maker_id->id);

chpr = newline(chpr);

if(model_pattern)

{

if(*model_pattern)

print_camera_models(maker_id->model,model_pattern);

else

print_camera_models(maker_id->model,NULL);

}

}

}

}

}

}

/* Print the list of recognized models for given device make. If a */

/* non-null pattern is passed as argument, limit the output to models */

/* for which a case-insensitive substring match to the pattern occurs */

/* in the name, otherwise print all names. */

void

print_camera_models(struct camera_id *model_names,char *pattern)

{

struct camera_id *maker_id;

int chpr = 0;

chpr = newline(0);

for(maker_id = model_names ; maker_id && maker_id->name; ++maker_id)

{

if(pattern)

{

if(STRCASESTR(maker_id->name,pattern))

{

chpr += printf("\t\t%-32.32s ",maker_id->name);

chpr += printf("\t[%2d,%d]",maker_id->id,

maker_id->noteversion);

chpr = newline(chpr);

}

}

else

{

chpr += printf("\t\t%-32.32s ",maker_id->name);

chpr += printf("\t[%2d,%d]",maker_id->id,

maker_id->noteversion);

chpr = newline(chpr);

}

}

}

char *

fake_strcasestr(char *string,char *pattern)

{

char *match = CNULL;

int plen,slen;

if(string && pattern)

{

plen = strlen(pattern);

if(plen == 0)

match = string;

else

{

slen = strlen(string);

while(plen <= slen)

{

if(strncasecmp(string,pattern,plen) == 0)

{

match = string;

break;

}

++string;

--slen;

}

}

}

return(match);

}