From bc145d8dc8a12812accd4586c37e38dee98e18ba Mon Sep 17 00:00:00 2001 From: Francois-Olivier Devaux Date: Fri, 8 Dec 2006 17:04:31 +0000 Subject: [PATCH] MJ2 codec restructuration. Created MJ2_codec directory and moved M2 codec files to this directory --- mj2/MJ2_codec/MJ2_Extractor.dsp | 128 ++ mj2/MJ2_codec/MJ2_Wrapper.dsp | 136 ++ mj2/MJ2_codec/Makefile | 79 + mj2/MJ2_codec/extract_j2k_from_mj2.c | 81 + mj2/MJ2_codec/frames_to_mj2.c | 997 ++++++++ mj2/MJ2_codec/frames_to_mj2.dsp | 269 +++ mj2/MJ2_codec/meta_out.c | 2185 ++++++++++++++++++ mj2/MJ2_codec/meta_out.h | 13 + mj2/MJ2_codec/mj2.c | 2798 +++++++++++++++++++++++ mj2/MJ2_codec/mj2.h | 201 ++ mj2/MJ2_codec/mj2_convert.c | 318 +++ mj2/MJ2_codec/mj2_convert.h | 16 + mj2/MJ2_codec/mj2_to_frames.c | 130 ++ mj2/MJ2_codec/mj2_to_frames.dsp | 305 +++ mj2/MJ2_codec/mj2_to_metadata.c | 281 +++ mj2/MJ2_codec/mj2_to_metadata.dsp | 276 +++ mj2/MJ2_codec/mj2_to_metadata.dtd | 425 ++++ mj2/MJ2_codec/mj2_to_metadata.h | 9 + mj2/MJ2_codec/mj2_to_metadata.vcproj | 324 +++ mj2/MJ2_codec/mj2_to_metadata_Notes.doc | Bin 0 -> 35328 bytes mj2/MJ2_codec/readme.txt | 3 + mj2/MJ2_codec/wrap_j2k_in_mj2.c | 287 +++ 22 files changed, 9261 insertions(+) create mode 100644 mj2/MJ2_codec/MJ2_Extractor.dsp create mode 100644 mj2/MJ2_codec/MJ2_Wrapper.dsp create mode 100644 mj2/MJ2_codec/Makefile create mode 100644 mj2/MJ2_codec/extract_j2k_from_mj2.c create mode 100644 mj2/MJ2_codec/frames_to_mj2.c create mode 100644 mj2/MJ2_codec/frames_to_mj2.dsp create mode 100644 mj2/MJ2_codec/meta_out.c create mode 100644 mj2/MJ2_codec/meta_out.h create mode 100644 mj2/MJ2_codec/mj2.c create mode 100644 mj2/MJ2_codec/mj2.h create mode 100644 mj2/MJ2_codec/mj2_convert.c create mode 100644 mj2/MJ2_codec/mj2_convert.h create mode 100644 mj2/MJ2_codec/mj2_to_frames.c create mode 100644 mj2/MJ2_codec/mj2_to_frames.dsp create mode 100644 mj2/MJ2_codec/mj2_to_metadata.c create mode 100644 mj2/MJ2_codec/mj2_to_metadata.dsp create mode 100644 mj2/MJ2_codec/mj2_to_metadata.dtd create mode 100644 mj2/MJ2_codec/mj2_to_metadata.h create mode 100644 mj2/MJ2_codec/mj2_to_metadata.vcproj create mode 100644 mj2/MJ2_codec/mj2_to_metadata_Notes.doc create mode 100644 mj2/MJ2_codec/readme.txt create mode 100644 mj2/MJ2_codec/wrap_j2k_in_mj2.c diff --git a/mj2/MJ2_codec/MJ2_Extractor.dsp b/mj2/MJ2_codec/MJ2_Extractor.dsp new file mode 100644 index 00000000..b1bdf18a --- /dev/null +++ b/mj2/MJ2_codec/MJ2_Extractor.dsp @@ -0,0 +1,128 @@ +# Microsoft Developer Studio Project File - Name="MJ2_Extractor" - Package Owner=<4> +# Microsoft Developer Studio Generated Build File, Format Version 6.00 +# ** DO NOT EDIT ** + +# TARGTYPE "Win32 (x86) Console Application" 0x0103 + +CFG=MJ2_Extractor - Win32 Debug +!MESSAGE This is not a valid makefile. To build this project using NMAKE, +!MESSAGE use the Export Makefile command and run +!MESSAGE +!MESSAGE NMAKE /f "MJ2_Extractor.mak". +!MESSAGE +!MESSAGE You can specify a configuration when running NMAKE +!MESSAGE by defining the macro CFG on the command line. For example: +!MESSAGE +!MESSAGE NMAKE /f "MJ2_Extractor.mak" CFG="MJ2_Extractor - Win32 Debug" +!MESSAGE +!MESSAGE Possible choices for configuration are: +!MESSAGE +!MESSAGE "MJ2_Extractor - Win32 Release" (based on "Win32 (x86) Console Application") +!MESSAGE "MJ2_Extractor - Win32 Debug" (based on "Win32 (x86) Console Application") +!MESSAGE + +# Begin Project +# PROP AllowPerConfigDependencies 0 +# PROP Scc_ProjName "" +# PROP Scc_LocalPath "" +CPP=cl.exe +RSC=rc.exe + +!IF "$(CFG)" == "MJ2_Extractor - Win32 Release" + +# PROP BASE Use_MFC 0 +# PROP BASE Use_Debug_Libraries 0 +# PROP BASE Output_Dir "Release" +# PROP BASE Intermediate_Dir "Release" +# PROP BASE Target_Dir "" +# PROP Use_MFC 0 +# PROP Use_Debug_Libraries 0 +# PROP Output_Dir "Release" +# PROP Intermediate_Dir "Release" +# PROP Target_Dir "" +# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c +# ADD CPP /nologo /W3 /GX /O2 /I "../libopenjpeg" /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c +# ADD BASE RSC /l 0x809 /d "NDEBUG" +# ADD RSC /l 0x809 /d "NDEBUG" +BSC32=bscmake.exe +# ADD BASE BSC32 /nologo +# ADD BSC32 /nologo +LINK32=link.exe +# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386 +# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386 + +!ELSEIF "$(CFG)" == "MJ2_Extractor - Win32 Debug" + +# PROP BASE Use_MFC 0 +# PROP BASE Use_Debug_Libraries 1 +# PROP BASE Output_Dir "MJ2_Extractor___Win32_Debug" +# PROP BASE Intermediate_Dir "MJ2_Extractor___Win32_Debug" +# PROP BASE Target_Dir "" +# PROP Use_MFC 0 +# PROP Use_Debug_Libraries 1 +# PROP Output_Dir "MJ2_Extractor___Win32_Debug" +# PROP Intermediate_Dir "MJ2_Extractor___Win32_Debug" +# PROP Target_Dir "" +# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c +# ADD CPP /nologo /W3 /Gm /GX /ZI /Od /I "../libopenjpeg" /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c +# ADD BASE RSC /l 0x809 /d "_DEBUG" +# ADD RSC /l 0x809 /d "_DEBUG" +BSC32=bscmake.exe +# ADD BASE BSC32 /nologo +# ADD BSC32 /nologo +LINK32=link.exe +# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept +# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept + +!ENDIF + +# Begin Target + +# Name "MJ2_Extractor - Win32 Release" +# Name "MJ2_Extractor - Win32 Debug" +# Begin Group "Source Files" + +# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat" +# Begin Source File + +SOURCE=..\libopenjpeg\cio.c +# End Source File +# Begin Source File + +SOURCE=.\extract_j2k_from_mj2.c +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\jp2.c +# End Source File +# Begin Source File + +SOURCE=.\mj2.c +# End Source File +# End Group +# Begin Group "Header Files" + +# PROP Default_Filter "h;hpp;hxx;hm;inl" +# Begin Source File + +SOURCE=..\libopenjpeg\cio.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\j2k.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\jp2.h +# End Source File +# Begin Source File + +SOURCE=.\mj2.h +# End Source File +# End Group +# Begin Group "Resource Files" + +# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe" +# End Group +# End Target +# End Project diff --git a/mj2/MJ2_codec/MJ2_Wrapper.dsp b/mj2/MJ2_codec/MJ2_Wrapper.dsp new file mode 100644 index 00000000..e45777dd --- /dev/null +++ b/mj2/MJ2_codec/MJ2_Wrapper.dsp @@ -0,0 +1,136 @@ +# Microsoft Developer Studio Project File - Name="MJ2_Wrapper" - Package Owner=<4> +# Microsoft Developer Studio Generated Build File, Format Version 6.00 +# ** DO NOT EDIT ** + +# TARGTYPE "Win32 (x86) Console Application" 0x0103 + +CFG=MJ2_Wrapper - Win32 Debug +!MESSAGE This is not a valid makefile. To build this project using NMAKE, +!MESSAGE use the Export Makefile command and run +!MESSAGE +!MESSAGE NMAKE /f "MJ2_Wrapper.mak". +!MESSAGE +!MESSAGE You can specify a configuration when running NMAKE +!MESSAGE by defining the macro CFG on the command line. For example: +!MESSAGE +!MESSAGE NMAKE /f "MJ2_Wrapper.mak" CFG="MJ2_Wrapper - Win32 Debug" +!MESSAGE +!MESSAGE Possible choices for configuration are: +!MESSAGE +!MESSAGE "MJ2_Wrapper - Win32 Release" (based on "Win32 (x86) Console Application") +!MESSAGE "MJ2_Wrapper - Win32 Debug" (based on "Win32 (x86) Console Application") +!MESSAGE + +# Begin Project +# PROP AllowPerConfigDependencies 0 +# PROP Scc_ProjName "" +# PROP Scc_LocalPath "" +CPP=cl.exe +RSC=rc.exe + +!IF "$(CFG)" == "MJ2_Wrapper - Win32 Release" + +# PROP BASE Use_MFC 0 +# PROP BASE Use_Debug_Libraries 0 +# PROP BASE Output_Dir "Release" +# PROP BASE Intermediate_Dir "Release" +# PROP BASE Target_Dir "" +# PROP Use_MFC 0 +# PROP Use_Debug_Libraries 0 +# PROP Output_Dir "Release" +# PROP Intermediate_Dir "Release" +# PROP Target_Dir "" +# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c +# ADD CPP /nologo /W3 /GX /O2 /I "../libopenjpeg" /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c +# ADD BASE RSC /l 0x809 /d "NDEBUG" +# ADD RSC /l 0x809 /d "NDEBUG" +BSC32=bscmake.exe +# ADD BASE BSC32 /nologo +# ADD BSC32 /nologo +LINK32=link.exe +# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386 +# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386 + +!ELSEIF "$(CFG)" == "MJ2_Wrapper - Win32 Debug" + +# PROP BASE Use_MFC 0 +# PROP BASE Use_Debug_Libraries 1 +# PROP BASE Output_Dir "MJ2_Wrapper___Win32_Debug" +# PROP BASE Intermediate_Dir "MJ2_Wrapper___Win32_Debug" +# PROP BASE Target_Dir "" +# PROP Use_MFC 0 +# PROP Use_Debug_Libraries 1 +# PROP Output_Dir "MJ2_Wrapper___Win32_Debug" +# PROP Intermediate_Dir "MJ2_Wrapper___Win32_Debug" +# PROP Target_Dir "" +# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c +# ADD CPP /nologo /W3 /Gm /GX /ZI /Od /I "../libopenjpeg" /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c +# ADD BASE RSC /l 0x809 /d "_DEBUG" +# ADD RSC /l 0x809 /d "_DEBUG" +BSC32=bscmake.exe +# ADD BASE BSC32 /nologo +# ADD BSC32 /nologo +LINK32=link.exe +# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept +# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept + +!ENDIF + +# Begin Target + +# Name "MJ2_Wrapper - Win32 Release" +# Name "MJ2_Wrapper - Win32 Debug" +# Begin Group "Source Files" + +# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat" +# Begin Source File + +SOURCE=..\libopenjpeg\cio.c +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\int.c +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\jp2.c +# End Source File +# Begin Source File + +SOURCE=.\mj2.c +# End Source File +# Begin Source File + +SOURCE=.\wrap_j2k_in_mj2.c +# End Source File +# End Group +# Begin Group "Header Files" + +# PROP Default_Filter "h;hpp;hxx;hm;inl" +# Begin Source File + +SOURCE=..\libopenjpeg\cio.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\int.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\j2k.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\jp2.h +# End Source File +# Begin Source File + +SOURCE=.\mj2.h +# End Source File +# End Group +# Begin Group "Resource Files" + +# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe" +# End Group +# End Target +# End Project diff --git a/mj2/MJ2_codec/Makefile b/mj2/MJ2_codec/Makefile new file mode 100644 index 00000000..0cc9030e --- /dev/null +++ b/mj2/MJ2_codec/Makefile @@ -0,0 +1,79 @@ +# +# Valentin Mesaros (Octalis | DICE/UCL Belgium) +# 19 April 2005 +# +# Makefile for mj2 source files (frames_to_mj2, mj2_to_frames, extract_j2k_from_mj2, wrap_j2k_in_mj2) +# + +INCLUDES = -Imj2 \ + -I../libopenjpeg + +C_OPT = -Wall +CFLAGS = $(INCLUDES) $(C_OPT) + +CC = gcc + +OBJ_MJ2_DIR = obj +BIN_MJ2_DIR = bin +LIB_OPENJPEG_DIR = ../libopenjpeg/lib +LIB_OPENJPEG = $(LIB_OPENJPEG_DIR)/libopenjpeg.a + +all: $(OBJ_MJ2_DIR) $(BIN_MJ2_DIR) \ + $(BIN_MJ2_DIR)/frames_to_mj2 \ + $(BIN_MJ2_DIR)/mj2_to_frames \ + $(BIN_MJ2_DIR)/extract_j2k_from_mj2 \ + $(BIN_MJ2_DIR)/wrap_j2k_in_mj2 + + +$(OBJ_MJ2_DIR): + mkdir $(OBJ_MJ2_DIR) + +$(BIN_MJ2_DIR): + mkdir $(BIN_MJ2_DIR) + +$(OBJ_MJ2_DIR)/%.o: + $(CC) -c $(CFLAGS) -o $@ $< + +$(OBJ_MJ2_DIR)/frames_to_mj2.o: frames_to_mj2.c +$(OBJ_MJ2_DIR)/mj2_to_frames.o: mj2_to_frames.c +$(OBJ_MJ2_DIR)/mj2.o: mj2.c +$(OBJ_MJ2_DIR)/mj2_convert.o: mj2_convert.c +$(OBJ_MJ2_DIR)/extract_j2k_from_mj2.o: extract_j2k_from_mj2.c +$(OBJ_MJ2_DIR)/wrap_j2k_in_mj2.o: wrap_j2k_in_mj2.c + + + +MJ2_OBJS = $(addprefix $(OBJ_MJ2_DIR)/, mj2.o mj2_convert.o) + + +$(BIN_MJ2_DIR)/frames_to_mj2: $(OBJ_MJ2_DIR)/frames_to_mj2.o $(MJ2_OBJS) $(LIB_OPENJPEG) + $(CC) $(CFLAGS) \ + -o $(BIN_MJ2_DIR)/frames_to_mj2 \ + $(MJ2_OBJS) $(OBJ_MJ2_DIR)/frames_to_mj2.o \ + $(LIB_OPENJPEG) \ + -lm + + +$(BIN_MJ2_DIR)/mj2_to_frames: $(OBJ_MJ2_DIR)/mj2_to_frames.o $(MJ2_OBJS) $(LIB_OPENJPEG) + $(CC) $(CFLAGS) \ + -o $(BIN_MJ2_DIR)/mj2_to_frames \ + $(MJ2_OBJS) $(OBJ_MJ2_DIR)/mj2_to_frames.o \ + $(LIB_OPENJPEG) \ + -lm + + +$(BIN_MJ2_DIR)/extract_j2k_from_mj2: $(OBJ_MJ2_DIR)/extract_j2k_from_mj2.o $(MJ2_OBJS) $(LIB_OPENJPEG) + $(CC) $(CFLAGS) \ + -o $(BIN_MJ2_DIR)/extract_j2k_from_mj2 \ + $(MJ2_OBJS) $(OBJ_MJ2_DIR)/extract_j2k_from_mj2.o \ + $(LIB_OPENJPEG) \ + -lm +$(BIN_MJ2_DIR)/wrap_j2k_in_mj2: $(OBJ_MJ2_DIR)/wrap_j2k_in_mj2.o $(MJ2_OBJS) $(LIB_OPENJPEG) + $(CC) $(CFLAGS) \ + -o $(BIN_MJ2_DIR)/wrap_j2k_in_mj2 \ + $(MJ2_OBJS) $(OBJ_MJ2_DIR)/wrap_j2k_in_mj2.o \ + $(LIB_OPENJPEG) \ + -lm + +clean: + rm -f $(BIN_MJ2_DIR)/* $(OBJ_MJ2_DIR)/* \ No newline at end of file diff --git a/mj2/MJ2_codec/extract_j2k_from_mj2.c b/mj2/MJ2_codec/extract_j2k_from_mj2.c new file mode 100644 index 00000000..24f759f1 --- /dev/null +++ b/mj2/MJ2_codec/extract_j2k_from_mj2.c @@ -0,0 +1,81 @@ +#include +#include +#include + +#include "mj2.h" + +//MEMORY LEAK +#ifdef _DEBUG +#define _CRTDBG_MAP_ALLOC +#include // Must be included first +#include +#endif +//MEM + +jmp_buf j2k_error; + +int main(int argc, char *argv[]) { + + int tnum; + unsigned int snum; + mj2_movie_t movie; + mj2_tk_t *track; + mj2_sample_t *sample; + unsigned char* frame_codestream; + FILE *file, *outfile; + char outfilename[50]; + + if (argc != 3) { + printf("Bad syntax: Usage: MJ2_extractor mj2filename output_location\n"); + printf("Example: MJ2_extractor foreman.mj2 output/foreman\n"); + return 1; + } + + file = fopen(argv[1], "rb"); + + if (!file) { + fprintf(stderr, "failed to open %s for reading\n", argv[1]); + return 1; + } + + if (mj2_read_struct(file, &movie)) // Creating the movie structure + return 1; + + // Decode first video track + tnum = 0; + while (movie.tk[tnum].track_type != 0) + tnum ++; + + track = &movie.tk[tnum]; + + fprintf(stdout,"Extracting %d frames from file...\n",track->num_samples); + + for (snum=0; snum < track->num_samples; snum++) + { + sample = &track->sample[snum]; + frame_codestream = (unsigned char*) malloc (sample->sample_size-8); // Skipping JP2C marker + fseek(file,sample->offset+8,SEEK_SET); + fread(frame_codestream,sample->sample_size-8,1, file); // Assuming that jp and ftyp markers size do + + sprintf(outfilename,"%s_%d.j2k",argv[2],snum); + outfile = fopen(outfilename, "wb"); + if (!outfile) { + fprintf(stderr, "failed to open %s for writing\n",outfilename); + return 1; + } + fwrite(frame_codestream,sample->sample_size-8,1,outfile); + fclose(outfile); + free(frame_codestream); + } + fclose(file); + fprintf(stdout, "%d frames correctly extracted\n", snum); + mj2_memory_free(&movie); + + //MEMORY LEAK + #ifdef _DEBUG + _CrtDumpMemoryLeaks(); + #endif + //MEM + + return 0; +} \ No newline at end of file diff --git a/mj2/MJ2_codec/frames_to_mj2.c b/mj2/MJ2_codec/frames_to_mj2.c new file mode 100644 index 00000000..efbf218b --- /dev/null +++ b/mj2/MJ2_codec/frames_to_mj2.c @@ -0,0 +1,997 @@ +/* +* Copyright (c) 2003-2004, François-Olivier Devaux +* Copyright (c) 2002-2004, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions +* are met: +* 1. Redistributions of source code must retain the above copyright +* notice, this list of conditions and the following disclaimer. +* 2. Redistributions in binary form must reproduce the above copyright +* notice, this list of conditions and the following disclaimer in the +* documentation and/or other materials provided with the distribution. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS' +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +#include +#include +#include +#include +#include +#include +#ifndef DONT_HAVE_GETOPT +#include +#else +#include "compat/getopt.h" +#endif + +#include "mj2_convert.h" + +#define MJ2_MDAT 0x6d646174 +#define JP2_JP2C 0x6a703263 + +//MEMORY LEAK +#ifdef _DEBUG +#define _CRTDBG_MAP_ALLOC +#include // Must be included first +#include +#endif +//MEM + +jmp_buf j2k_error; + +void help_display() +{ + fprintf(stdout,"HELP\n----\n\n"); + fprintf(stdout,"- the -h option displays this help information on screen\n\n"); + + + fprintf(stdout,"List of parameters for the MJ2 encoder:\n"); + fprintf(stdout,"\n"); + fprintf(stdout,"REMARKS:\n"); + fprintf(stdout,"---------\n"); + fprintf(stdout,"\n"); + fprintf + (stdout,"The markers written to the main_header are : SOC SIZ COD QCD COM.\n"); + fprintf + (stdout,"COD and QCD never appear in the tile_header.\n"); + fprintf(stdout,"\n"); + fprintf + (stdout,"- This coder can encode a mega image, a test was made on a 24000x24000 pixels \n"); + fprintf + (stdout,"color image. You need enough disk space memory (twice the original) to encode \n"); + fprintf + (stdout,"the image,i.e. for a 1.5 GB image you need a minimum of 3GB of disk memory)\n"); + fprintf(stdout,"\n"); + fprintf(stdout,"By default:\n"); + fprintf(stdout,"------------\n"); + fprintf(stdout,"\n"); + fprintf(stdout," * Lossless\n"); + fprintf(stdout," * 1 tile\n"); + fprintf(stdout," * Size of precinct : 2^15 x 2^15 (means 1 precinct)\n"); + fprintf(stdout," * Size of code-block : 64 x 64\n"); + fprintf(stdout," * Number of resolutions: 6\n"); + fprintf(stdout," * No SOP marker in the codestream\n"); + fprintf(stdout," * No EPH marker in the codestream\n"); + fprintf(stdout," * No sub-sampling in x or y direction\n"); + fprintf(stdout," * No mode switch activated\n"); + fprintf(stdout," * Progression order: LRCP\n"); + fprintf(stdout," * No index file\n"); + fprintf(stdout," * No ROI upshifted\n"); + fprintf(stdout," * No offset of the origin of the image\n"); + fprintf(stdout," * No offset of the origin of the tiles\n"); + fprintf(stdout," * Reversible DWT 5-3\n"); + fprintf(stdout,"\n"); + fprintf(stdout,"Parameters:\n"); + fprintf(stdout,"------------\n"); + fprintf(stdout,"\n"); + fprintf + (stdout,"Required Parameters (except with -h):\n"); + fprintf + (stdout,"-i : source file (-i source.yuv) \n"); + fprintf + (stdout,"-o : destination file (-o dest.mj2) \n"); + fprintf + (stdout,"Optional Parameters:\n"); + fprintf(stdout,"-h : display the help information \n"); + fprintf(stdout,"-r : different compression ratios for successive layers (-r 20,10,5)\n "); + fprintf(stdout," - The rate specified for each quality level is the desired \n"); + fprintf(stdout," compression factor.\n"); + fprintf(stdout," Example: -r 20,10,1 means quality 1: compress 20x, \n"); + fprintf(stdout," quality 2: compress 10x and quality 3: compress lossless\n"); + fprintf(stdout," (options -r and -q cannot be used together)\n "); + + fprintf(stdout,"-q : different psnr for successive layers (-q 30,40,50) \n "); + + fprintf(stdout," (options -r and -q cannot be used together)\n "); + + fprintf(stdout,"-n : number of resolutions (-n 3) \n"); + fprintf(stdout,"-b : size of code block (-b 32,32) \n"); + fprintf(stdout,"-c : size of precinct (-c 128,128) \n"); + fprintf(stdout,"-t : size of tile (-t 512,512) \n"); + fprintf + (stdout,"-p : progression order (-p LRCP) [LRCP, RLCP, RPCL, PCRL, CPRL] \n"); + fprintf + (stdout,"-s : subsampling factor (-s 2,2) [-s X,Y] \n"); + fprintf(stdout," Remark: subsampling bigger than 2 can produce error\n"); + fprintf + (stdout,"-SOP : write SOP marker before each packet \n"); + fprintf + (stdout,"-EPH : write EPH marker after each header packet \n"); + fprintf + (stdout,"-M : mode switch (-M 3) [1=BYPASS(LAZY) 2=RESET 4=RESTART(TERMALL)\n"); + fprintf + (stdout," 8=VSC 16=ERTERM(SEGTERM) 32=SEGMARK(SEGSYM)] \n"); + fprintf + (stdout," Indicate multiple modes by adding their values. \n"); + fprintf + (stdout," ex: RESTART(4) + RESET(2) + SEGMARK(32) = -M 38\n"); + fprintf + (stdout,"-x : create an index file *.Idx (-x index_name.Idx) \n"); + fprintf + (stdout,"-ROI : c=%%d,U=%%d : quantization indices upshifted \n"); + fprintf + (stdout," for component c=%%d [%%d = 0,1,2]\n"); + fprintf + (stdout," with a value of U=%%d [0 <= %%d <= 37] (i.e. -ROI:c=0,U=25) \n"); + fprintf + (stdout,"-d : offset of the origin of the image (-d 150,300) \n"); + fprintf + (stdout,"-T : offset of the origin of the tiles (-T 100,75) \n"); + fprintf(stdout,"-I : use the irreversible DWT 9-7 (-I) \n"); + fprintf(stdout,"-W : image width, height and the dx and dy subsampling \n"); + fprintf(stdout," of the Cb and Cr components for YUV files \n"); + fprintf(stdout," (default is '352,288,2,2' for CIF format's 352x288 and 4:2:0)\n"); + fprintf(stdout,"-F : video frame rate (set to 25 by default)\n"); + + fprintf(stdout,"\n"); + fprintf(stdout,"IMPORTANT:\n"); + fprintf(stdout,"-----------\n"); + fprintf(stdout,"\n"); + fprintf(stdout,"The index file has the structure below:\n"); + fprintf(stdout,"---------------------------------------\n"); + fprintf(stdout,"\n"); + fprintf(stdout,"Image_height Image_width\n"); + fprintf(stdout,"progression order\n"); + fprintf(stdout,"Tiles_size_X Tiles_size_Y\n"); + fprintf(stdout,"Components_nb\n"); + fprintf(stdout,"Layers_nb\n"); + fprintf(stdout,"decomposition_levels\n"); + fprintf(stdout,"[Precincts_size_X_res_Nr Precincts_size_Y_res_Nr]...\n"); + fprintf(stdout," [Precincts_size_X_res_0 Precincts_size_Y_res_0]\n"); + fprintf(stdout,"Main_header_end_position\n"); + fprintf(stdout,"Codestream_size\n"); + fprintf(stdout,"Tile_0 start_pos end_Theader end_pos TotalDisto NumPix MaxMSE\n"); + fprintf(stdout,"Tile_1 '' '' '' '' '' ''\n"); + fprintf(stdout,"...\n"); + fprintf(stdout,"Tile_Nt '' '' '' '' '' ''\n"); + fprintf(stdout,"Tpacket_0 Tile layer res. comp. prec. start_pos end_pos disto\n"); + fprintf(stdout,"...\n"); + fprintf(stdout,"Tpacket_Np '' '' '' '' '' '' '' ''\n"); + + fprintf(stdout,"MaxDisto\n"); + + fprintf(stdout,"TotalDisto\n\n"); +} + +int give_progression(char progression[4]) +{ + if (progression[0] == 'L' && progression[1] == 'R' + && progression[2] == 'C' && progression[3] == 'P') { + return 0; + } else { + if (progression[0] == 'R' && progression[1] == 'L' + && progression[2] == 'C' && progression[3] == 'P') { + return 1; + } else { + if (progression[0] == 'R' && progression[1] == 'P' + && progression[2] == 'C' && progression[3] == 'L') { + return 2; + } else { + if (progression[0] == 'P' && progression[1] == 'C' + && progression[2] == 'R' && progression[3] == 'L') { + return 3; + } else { + if (progression[0] == 'C' && progression[1] == 'P' + && progression[2] == 'R' && progression[3] == 'L') { + return 4; + } else { + return -1; + } + } + } + } + } +} + +double dwt_norms_97[4][10] = { + {1.000, 1.965, 4.177, 8.403, 16.90, 33.84, 67.69, 135.3, 270.6, 540.9}, + {2.022, 3.989, 8.355, 17.04, 34.27, 68.63, 137.3, 274.6, 549.0}, + {2.022, 3.989, 8.355, 17.04, 34.27, 68.63, 137.3, 274.6, 549.0}, + {2.080, 3.865, 8.307, 17.18, 34.71, 69.59, 139.3, 278.6, 557.2} +}; + +int floorlog2(int a) +{ + int l; + for (l = 0; a > 1; l++) { + a >>= 1; + } + return l; +} + +void encode_stepsize(int stepsize, int numbps, int *expn, int *mant) +{ + int p, n; + p = floorlog2(stepsize) - 13; + n = 11 - floorlog2(stepsize); + *mant = (n < 0 ? stepsize >> -n : stepsize << n) & 0x7ff; + *expn = numbps - p; +} + +void calc_explicit_stepsizes(j2k_tccp_t * tccp, int prec) +{ + int numbands, bandno; + numbands = 3 * tccp->numresolutions - 2; + for (bandno = 0; bandno < numbands; bandno++) { + double stepsize; + + int resno, level, orient, gain; + resno = bandno == 0 ? 0 : (bandno - 1) / 3 + 1; + orient = bandno == 0 ? 0 : (bandno - 1) % 3 + 1; + level = tccp->numresolutions - 1 - resno; + gain = + tccp->qmfbid == 0 ? 0 : (orient == + 0 ? 0 : (orient == 1 + || orient == 2 ? 1 : 2)); + if (tccp->qntsty == J2K_CCP_QNTSTY_NOQNT) { + stepsize = 1.0; + } else { + double norm = dwt_norms_97[orient][level]; + stepsize = (1 << (gain + 1)) / norm; + } + encode_stepsize((int) floor(stepsize * 8192.0), prec + gain, + &tccp->stepsizes[bandno].expn, + &tccp->stepsizes[bandno].mant); + } +} + +int main(int argc, char **argv) +{ + int NumResolution, numD_min; /* NumResolution : number of resolution */ + int Tile_arg; /* Tile_arg = 0 (not in argument) ou = 1 (in argument) */ + int CSty; /* CSty : coding style */ + int Prog_order; /* progression order (default LRCP) */ + char progression[4]; + int numpocs, numpocs_tile; /* Number of progression order change (POC) default 0 */ + int prcw_init[J2K_MAXRLVLS]; /* Initialisation Precinct width */ + int prch_init[J2K_MAXRLVLS]; /* Initialisation Precinct height */ + //int prcw_init, prch_init; /* Initialisation precincts' size */ + int cblockw_init, cblockh_init; /* Initialisation codeblocks' size */ + int mode, value; /* Mode switch (cblk_style) */ + int subsampling_dx, subsampling_dy; /* subsampling value for dx and dy */ + int ROI_compno, ROI_shift; /* region of interrest */ + int Dim[2]; /* portion of the image coded */ + int TX0, TY0; /* tile off-set */ + mj2_movie_t movie; + j2k_cp_t cp, cp_init; /* cp_init is used to initialise in multiple tiles */ + j2k_tcp_t *tcp, *tcp_init; /* tcp_init is used to initialise in multiple tile */ + j2k_poc_t POC[32]; /* POC : used in case of Progression order change */ + j2k_poc_t *tcp_poc; + j2k_tccp_t *tccp; + int i, tileno, l, j; + char *infile = 0; + char *outfile = 0; + char *index = 0; + char *s, S1, S2, S3; + char *buf; + int ir = 0; + int res_spec = 0; /* For various precinct sizes specification */ + char sep; + int w; /* Width of YUV file */ + int h; /* Height of YUV file */ + int CbCr_subsampling_dx; /* Sample rate of YUV 4:4:4 4:2:2 or 4:2:0 */ + int CbCr_subsampling_dy; /* Sample rate of YUV 4:4:4 4:2:2 or 4:2:0 */ + int frame_rate; /* Video Frame Rate */ + int numcomps; /* In YUV files, numcomps always considered as 3 */ + int prec; /* In YUV files, precision always considered as 8 */ + int x1, y1, len, jp2c_initpos, m, k, pos; + long mdat_initpos, offset; + FILE *mj2file, *yuvfile; + unsigned int sampleno; + j2k_image_t img; + + /* default value */ + /* ------------- */ + NumResolution = 6; + CSty = 0; + cblockw_init = 64; + cblockh_init = 64; + cp.tw = 1; + cp.th = 1; + cp.index_on = 0; + Prog_order = 0; + numpocs = 0; + mode = 0; + subsampling_dx = 1; + subsampling_dy = 1; + ROI_compno = -1; /* no ROI */ + ROI_shift = 0; + Dim[0] = 0; + Dim[1] = 0; + TX0 = 0; + TY0 = 0; + cp.comment = NULL; + cp.disto_alloc = 0; + cp.fixed_alloc = 0; + cp.fixed_quality = 0; //add fixed_quality + w = 352; // CIF default value + h = 288; // CIF default value + CbCr_subsampling_dx = 2; // CIF default value + CbCr_subsampling_dy = 2; // CIF default value + frame_rate = 25; + + + Tile_arg = 0; + cp_init.tcps = (j2k_tcp_t *) malloc(sizeof(j2k_tcp_t)); /* initialisation if only one tile */ + tcp_init = &cp_init.tcps[0]; + tcp_init->numlayers = 0; + + cp.intermed_file = 0; // Don't store each tile in a file during processing + + while (1) { + int c = getopt(argc, argv, + "i:o:r:q:f:t:n:c:b:x:p:s:d:h:P:S:E:M:R:T:C:I:W:F:"); + if (c == -1) + break; + switch (c) { + case 'i': /* IN fill */ + infile = optarg; + s = optarg; + while (*s) { + s++; + } + s--; + S3 = *s; + s--; + S2 = *s; + s--; + S1 = *s; + + if ((S1 == 'y' && S2 == 'u' && S3 == 'v') + || (S1 == 'Y' && S2 == 'U' && S3 == 'V')) { + cp.decod_format = YUV_DFMT; + break; + } + fprintf(stderr, + "!! Unrecognized format for infile : %c%c%c [accept only *.yuv] !!\n\n", + S1, S2, S3); + return 1; + break; + /* ----------------------------------------------------- */ + case 'o': /* OUT fill */ + outfile = optarg; + while (*outfile) { + outfile++; + } + outfile--; + S3 = *outfile; + outfile--; + S2 = *outfile; + outfile--; + S1 = *outfile; + + outfile = optarg; + + if ((S1 == 'm' && S2 == 'j' && S3 == '2') + || (S1 == 'M' && S2 == 'J' && S3 == '2')) + cp.cod_format = MJ2_CFMT; + else { + fprintf(stderr, + "Unknown output format image *.%c%c%c [only *.mj2]!! \n", + S1, S2, S3); + return 1; + } + + + + break; + /* ----------------------------------------------------- */ + case 'r': /* rates rates/distorsion */ + s = optarg; + while (sscanf(s, "%d", &tcp_init->rates[tcp_init->numlayers]) + == 1) { + tcp_init->numlayers++; + while (*s && *s != ',') { + s++; + } + if (!*s) + break; + s++; + } + cp.disto_alloc = 1; + cp.matrice = NULL; + break; + /* ----------------------------------------------------- */ + case 'q': /* add fixed_quality */ + s = optarg; + while (sscanf + (s, "%f", &tcp_init->distoratio[tcp_init->numlayers]) == 1) { + tcp_init->numlayers++; + while (*s && *s != ',') { + s++; + } + if (!*s) + break; + s++; + } + cp.fixed_quality = 1; + cp.matrice = NULL; + break; + /* dda */ + /* ----------------------------------------------------- */ + case 'f': /* mod fixed_quality (before : -q) */ + s = optarg; + sscanf(s, "%d", &tcp_init->numlayers); + s++; + if (tcp_init->numlayers > 9) + s++; + cp.matrice = + (int *) malloc(tcp_init->numlayers * NumResolution * 3 * + sizeof(int)); + s = s + 2; + for (i = 0; i < tcp_init->numlayers; i++) { + tcp_init->rates[i] = 1; + sscanf(s, "%d,", &cp.matrice[i * NumResolution * 3]); + s += 2; + if (cp.matrice[i * NumResolution * 3] > 9) + s++; + cp.matrice[i * NumResolution * 3 + 1] = 0; + cp.matrice[i * NumResolution * 3 + 2] = 0; + for (j = 1; j < NumResolution; j++) { + sscanf(s, "%d,%d,%d", + &cp.matrice[i * NumResolution * 3 + j * 3 + 0], + &cp.matrice[i * NumResolution * 3 + j * 3 + 1], + &cp.matrice[i * NumResolution * 3 + j * 3 + 2]); + s += 6; + if (cp.matrice[i * NumResolution * 3 + j * 3] > 9) + s++; + if (cp.matrice[i * NumResolution * 3 + j * 3 + 1] > 9) + s++; + if (cp.matrice[i * NumResolution * 3 + j * 3 + 2] > 9) + s++; + } + if (i < tcp_init->numlayers - 1) + s++; + } + cp.fixed_alloc = 1; + break; + /* ----------------------------------------------------- */ + case 't': /* tiles */ + sscanf(optarg, "%d,%d", &cp.tdx, &cp.tdy); + Tile_arg = 1; + break; + /* ----------------------------------------------------- */ + case 'n': /* resolution */ + sscanf(optarg, "%d", &NumResolution); + break; + /* ----------------------------------------------------- */ + case 'c': /* precinct dimension */ + s = optarg; + do { + sep = 0; + sscanf(s, "[%d,%d]%c", &prcw_init[res_spec], + &prch_init[res_spec], &sep); + CSty |= 0x01; + res_spec++; + s = strpbrk(s, "]") + 2; + } while (sep == ','); + break; + /* ----------------------------------------------------- */ + case 'b': /* code-block dimension */ + sscanf(optarg, "%d,%d", &cblockw_init, &cblockh_init); + if (cblockw_init * cblockh_init > 4096 || cblockw_init > 1024 + || cblockw_init < 4 || cblockh_init > 1024 || cblockh_init < 4) { + fprintf(stderr, + "!! Size of code_block error (option -b) !!\n\nRestriction :\n * width*height<=4096\n * 4<=width,height<= 1024\n\n"); + return 1; + } + break; + /* ----------------------------------------------------- */ + case 'x': /* creation of index file */ + index = optarg; + cp.index_on = 1; + break; + /* ----------------------------------------------------- */ + case 'p': /* progression order */ + s = optarg; + for (i = 0; i < 4; i++) { + progression[i] = *s; + s++; + } + Prog_order = give_progression(progression); + + if (Prog_order == -1) { + fprintf(stderr, + "Unrecognized progression order [LRCP, RLCP, RPCL, PCRL, CPRL] !!\n"); + return 1; + } + break; + /* ----------------------------------------------------- */ + case 's': /* subsampling factor */ + if (sscanf(optarg, "%d,%d", &subsampling_dx, &subsampling_dy) + != 2) { + fprintf(stderr, + "'-s' sub-sampling argument error ! [-s dx,dy]\n"); + return 1; + } + break; + /* ----------------------------------------------------- */ + case 'd': /* coordonnate of the reference grid */ + if (sscanf(optarg, "%d,%d", &Dim[0], &Dim[1]) != 2) { + fprintf(stderr, + "-d 'coordonnate of the reference grid' argument error !! [-d x0,y0]\n"); + return 1; + } + break; + /* ----------------------------------------------------- */ + case 'h': /* Display an help description */ + help_display(); + return 0; + break; + /* ----------------------------------------------------- */ + case 'P': /* POC */ + fprintf(stderr, "/----------------------------------\\\n"); + fprintf(stderr, "| POC option not fully tested !! |\n"); + fprintf(stderr, "\\----------------------------------/\n"); + + s = optarg; + while (sscanf(s, "T%d=%d,%d,%d,%d,%d,%s", &POC[numpocs].tile, + &POC[numpocs].resno0, &POC[numpocs].compno0, + &POC[numpocs].layno1, &POC[numpocs].resno1, + &POC[numpocs].compno1, POC[numpocs].progorder) == 7) { + POC[numpocs].prg = give_progression(POC[numpocs].progorder); + /* POC[numpocs].tile; */ + numpocs++; + while (*s && *s != '/') { + s++; + } + if (!*s) + break; + s++; + } + break; + /* ------------------------------------------------------ */ + case 'S': /* SOP marker */ + CSty |= 0x02; + break; + /* ------------------------------------------------------ */ + case 'E': /* EPH marker */ + CSty |= 0x04; + break; + /* ------------------------------------------------------ */ + case 'M': /* Mode switch pas tous au point !! */ + if (sscanf(optarg, "%d", &value) == 1) { + for (i = 0; i <= 5; i++) { + int cache = value & (1 << i); + if (cache) + mode |= (1 << i); + } + } + break; + /* ------------------------------------------------------ */ + case 'R': /* ROI */ + if (sscanf(optarg, "OI:c=%d,U=%d", &ROI_compno, &ROI_shift) != 2) { + fprintf(stderr, "ROI error !! [-ROI:c='compno',U='shift']\n"); + return 1; + } + break; + /* ------------------------------------------------------ */ + case 'T': /* Tile offset */ + if (sscanf(optarg, "%d,%d", &TX0, &TY0) != 2) { + fprintf(stderr, "-T 'tile offset' argument error !! [-T X0,Y0]"); + return 1; + } + break; + /* ------------------------------------------------------ */ + case 'C': /* Add a comment */ + cp.comment = optarg; + break; + /* ------------------------------------------------------ */ + case 'I': /* reversible or not */ + ir = 1; + break; + /* ------------------------------------------------------ */ + case 'W': /* Width and Height and Cb and Cr subsampling in case of YUV format files */ + if (sscanf + (optarg, "%d,%d,%d,%d", &w, &h, &CbCr_subsampling_dx, + &CbCr_subsampling_dy) != 4) { + fprintf(stderr, "-W argument error"); + return 1; + } + break; + /* ------------------------------------------------------ */ + case 'F': /* Video frame rate */ + if (sscanf(optarg, "%d", &frame_rate) != 1) { + fprintf(stderr, "-F argument error"); + return 1; + } + break; + /* ------------------------------------------------------ */ + default: + return 1; + } + } + + cp.tx0 = TX0; + cp.ty0 = TY0; + + /* Error messages */ + /* -------------- */ + if (!infile || !outfile) { + fprintf(stderr, + "Correct usage: mj2_encoder -i yuv-file -o mj2-file (+ options)\n"); + return 1; + } + + if ((cp.disto_alloc || cp.fixed_alloc || cp.fixed_quality) + && (!(cp.disto_alloc ^ cp.fixed_alloc ^ cp.fixed_quality))) { + fprintf(stderr, + "Error: options -r -q and -f can not be used together !!\n"); + return 1; + } // mod fixed_quality + + /* if no rate entered, lossless by default */ + if (tcp_init->numlayers == 0) { + tcp_init->rates[tcp_init->numlayers] = 0; //MOD antonin : losslessbug + tcp_init->numlayers++; + cp.disto_alloc = 1; + } + + if (TX0 > Dim[0] || TY0 > Dim[1]) { + fprintf(stderr, + "Error: Tile offset dimension is unnappropriate --> TX0(%d)<=IMG_X0(%d) TYO(%d)<=IMG_Y0(%d) \n", + TX0, Dim[0], TY0, Dim[1]); + return 1; + } + + for (i = 0; i < numpocs; i++) { + if (POC[i].prg == -1) { + fprintf(stderr, + "Unrecognized progression order in option -P (POC n %d) [LRCP, RLCP, RPCL, PCRL, CPRL] !!\n", + i + 1); + } + } + + /* to respect profile - 0 */ + /* ---------------------- */ + numD_min = 0; + + x1 = !Dim[0] ? (w - 1) * subsampling_dx + 1 : Dim[0] + (w - + 1) * + subsampling_dx + 1; + y1 = !Dim[1] ? (h - 1) * subsampling_dy + 1 : Dim[1] + (h - + 1) * + subsampling_dy + 1; + + if (Tile_arg == 1) { + cp.tw = int_ceildiv(x1 - cp.tx0, cp.tdx); + cp.th = int_ceildiv(y1 - cp.ty0, cp.tdy); + } else { + cp.tdx = x1 - cp.tx0; + cp.tdy = y1 - cp.ty0; + } + + + /* Initialization for PPM marker */ + cp.ppm = 0; + cp.ppm_data = NULL; + cp.ppm_previous = 0; + cp.ppm_store = 0; + + numcomps = 3; /* Because YUV files only have 3 components */ + + tcp_init->mct = 0; /* No component transform needed */ + + prec = 8; /* Because in YUV files, components have 8-bit depth */ + + /* Init the mutiple tiles */ + /* ---------------------- */ + cp.tcps = (j2k_tcp_t *) malloc(cp.tw * cp.th * sizeof(j2k_tcp_t)); + + for (tileno = 0; tileno < cp.tw * cp.th; tileno++) { + tcp = &cp.tcps[tileno]; + tcp->numlayers = tcp_init->numlayers; + for (j = 0; j < tcp->numlayers; j++) { + if (cp.fixed_quality) // add fixed_quality + tcp->distoratio[j] = tcp_init->distoratio[j]; + else + tcp->rates[j] = tcp_init->rates[j]; + } + tcp->csty = CSty; + tcp->prg = Prog_order; + tcp->mct = tcp_init->mct; + tcp->ppt = 0; + tcp->ppt_data = NULL; + tcp->ppt_store = 0; + + numpocs_tile = 0; + tcp->POC = 0; + if (numpocs) { + /* intialisation of POC */ + tcp->POC = 1; + for (i = 0; i < numpocs; i++) { + if (tileno == POC[i].tile - 1 || POC[i].tile == -1) { + tcp_poc = &tcp->pocs[numpocs_tile]; + tcp_poc->resno0 = POC[numpocs_tile].resno0; + tcp_poc->compno0 = POC[numpocs_tile].compno0; + tcp_poc->layno1 = POC[numpocs_tile].layno1; + tcp_poc->resno1 = POC[numpocs_tile].resno1; + tcp_poc->compno1 = POC[numpocs_tile].compno1; + tcp_poc->prg = POC[numpocs_tile].prg; + tcp_poc->tile = POC[numpocs_tile].tile; + numpocs_tile++; + } + } + } + tcp->numpocs = numpocs_tile; + tcp->tccps = (j2k_tccp_t *) malloc(numcomps * sizeof(j2k_tccp_t)); + + for (i = 0; i < numcomps; i++) { + tccp = &tcp->tccps[i]; + tccp->csty = CSty & 0x01; /* 0 => one precinct || 1 => custom precinct */ + tccp->numresolutions = NumResolution; + tccp->cblkw = int_floorlog2(cblockw_init); + tccp->cblkh = int_floorlog2(cblockh_init); + tccp->cblksty = mode; + tccp->qmfbid = ir ? 0 : 1; + tccp->qntsty = ir ? J2K_CCP_QNTSTY_SEQNT : J2K_CCP_QNTSTY_NOQNT; + tccp->numgbits = 2; + if (i == ROI_compno) + tccp->roishift = ROI_shift; + else + tccp->roishift = 0; + if (CSty & J2K_CCP_CSTY_PRT) { + int p = 0; + for (j = tccp->numresolutions - 1; j >= 0; j--) { + if (p < res_spec) { + if (prcw_init[p] < 1) + tccp->prcw[j] = 1; + else + tccp->prcw[j] = int_floorlog2(prcw_init[p]); + + if (prch_init[p] < 1) + tccp->prch[j] = 1; + else + tccp->prch[j] = int_floorlog2(prch_init[p]); + } else { + int size_prcw, size_prch; + size_prcw = prcw_init[res_spec - 1] >> (p - (res_spec - 1)); + size_prch = prch_init[res_spec - 1] >> (p - (res_spec - 1)); + if (size_prcw < 1) + tccp->prcw[j] = 1; + else + tccp->prcw[j] = int_floorlog2(size_prcw); + if (size_prch < 1) + tccp->prch[j] = 1; + else + tccp->prch[j] = int_floorlog2(size_prch); + } + p++; + /*printf("\nsize precinct pour level %d : %d,%d\n", j, + tccp->prcw[j], tccp->prch[j]); */ + } + } else { + for (j = 0; j < tccp->numresolutions; j++) { + tccp->prcw[j] = 15; + tccp->prch[j] = 15; + } + } + calc_explicit_stepsizes(tccp, prec); + } + } + + mj2file = fopen(outfile, "wb"); + + if (!mj2file) { + fprintf(stderr, "failed to open %s for writing\n", argv[2]); + return 1; + } + + movie.tk = (mj2_tk_t *) malloc(sizeof(mj2_tk_t)); + movie.num_vtk = 1; + movie.num_stk = 0; + movie.num_htk = 0; + + movie.tk[0].track_type = 0; // Video Track + movie.tk[0].track_ID = 1; + movie.tk[0].Dim[0] = Dim[0]; + movie.tk[0].Dim[1] = Dim[1]; + movie.tk[0].w = w; + movie.tk[0].h = h; + movie.tk[0].CbCr_subsampling_dx = CbCr_subsampling_dx; + movie.tk[0].CbCr_subsampling_dy = CbCr_subsampling_dy; + movie.tk[0].sample_rate = frame_rate; + movie.tk[0].jp2_struct.numcomps = 3; // NC + jp2_init_stdjp2(&movie.tk[0].jp2_struct); + + movie.tk[0].jp2_struct.w = w; + movie.tk[0].jp2_struct.h = h; + movie.tk[0].jp2_struct.bpc = 7; + movie.tk[0].jp2_struct.meth = 1; + movie.tk[0].jp2_struct.enumcs = 18; // YUV + + + yuvfile = fopen(infile,"rb"); + if (!yuvfile) { + fprintf(stderr, "failed to open %s for reading\n",infile); + return 1; + } + + movie.tk[0].num_samples = yuv_num_frames(&movie.tk[0],yuvfile); + if (!movie.tk[0].num_samples) { + fprintf(stderr,"Unable to count the number of frames in YUV input file\n"); + } + + // One sample per chunk + movie.tk[0].chunk = (mj2_chunk_t*) malloc(movie.tk[0].num_samples * sizeof(mj2_chunk_t)); + movie.tk[0].sample = (mj2_sample_t*) malloc(movie.tk[0].num_samples * sizeof(mj2_sample_t)); + + if (mj2_init_stdmovie(&movie)) { + fprintf(stderr, "Error with movie initialization"); + return 1; + }; + + // Writing JP, FTYP and MDAT boxes + buf = (char*) malloc (300 * sizeof(char)); // Assuming that the JP and FTYP + // boxes won't be longer than 300 bytes + cio_init(buf , 300); + mj2_write_jp(); + mj2_write_ftyp(&movie); + mdat_initpos = cio_tell(); + cio_skip(4); + cio_write(MJ2_MDAT, 4); + fwrite(buf,cio_tell(),1,mj2file); + offset = cio_tell(); + free(buf); + + for (i = 0; i < movie.num_stk + movie.num_htk + movie.num_vtk; i++) { + if (movie.tk[i].track_type != 0) { + fprintf(stderr, "Unable to write sound or hint tracks\n"); + } else { + //j2k_cp_t cp_init; + mj2_tk_t *tk; + + tk = &movie.tk[i]; + + //tk->sample = + //(mj2_sample_t *) malloc(tk->num_samples * sizeof(mj2_sample_t)); + tk->num_chunks = tk->num_samples; + //tk->chunk = + //(mj2_chunk_t *) malloc(tk->num_chunks * sizeof(mj2_chunk_t)); + + fprintf(stderr, "Video Track number %d\n", i + 1); + + // Copy the first tile coding parameters (tcp) to cp_init + + //cp_init.tcps = + //(j2k_tcp_t *) malloc(cp.tw * cp.th * sizeof(j2k_tcp_t)); + for (tileno = 0; tileno < cp.tw * cp.th; tileno++) { + for (l = 0; l < cp.tcps[tileno].numlayers; l++) { + cp_init.tcps[tileno].rates[l] = cp.tcps[tileno].rates[l]; + //tileno = cp.tcps[tileno].rates[l]; + } + } + + for (sampleno = 0; sampleno < tk->num_samples; sampleno++) { + buf = (char *) malloc(cp.tdx * cp.tdy * cp.th * cp.tw * 2); + cio_init(buf, cp.tdx * cp.tdy * cp.th * cp.tw * 2); + + fprintf(stderr, "Frame number %d/%d: ", sampleno + 1, tk->num_samples); + + + if (!yuvtoimage(yuvfile, tk, &img, sampleno, subsampling_dx, subsampling_dy)) { + fprintf(stderr, "Error with frame number %d in YUV file\n", sampleno); + return 1; + } + + jp2c_initpos = cio_tell(); + cio_skip(4); + cio_write(JP2_JP2C, 4); // JP2C + + len = j2k_encode(&img, &cp, buf, cp.tdx * cp.tdy * 2, index); + if (len ==0) { + fprintf(stderr,"Unable to encode image"); + return 1; + } + + cio_seek(jp2c_initpos); + cio_write(len+8,4); + + for (m = 0; m < img.numcomps; m++) { + free(img.comps[m].data); + } + free(img.comps); + + tk->sample[sampleno].sample_size = len+8; + + tk->sample[sampleno].offset = offset; + tk->chunk[sampleno].offset = offset; // There is one sample per chunk + + fwrite(buf, 1, len+8, mj2file); + + offset += len+8; + + free(buf); + + // Copy the cp_init parameters to cp.tcps + + for (tileno = 0; tileno < cp.tw * cp.th; tileno++) { + for (k = 0; k < cp.tcps[tileno].numlayers; k++) { + cp.tcps[tileno].rates[k] = cp_init.tcps[tileno].rates[k]; + } + } + } + } + } + + fseek(mj2file, mdat_initpos, SEEK_SET); + + buf = (char*) malloc(4*sizeof(char)); + + cio_init(buf, 4); // Init a cio to write box length variable in a little endian way + cio_write(offset - mdat_initpos, 4); + fwrite(buf, 4, 1, mj2file); + fseek(mj2file,0,SEEK_END); + free(buf); + + // Writing MOOV box + i=1; + buf = (char*) malloc (10000 * sizeof(char)); + cio_init(buf , i*10000); + if (setjmp(j2k_error)) { + i++; + realloc(buf,i*10000* sizeof(char)); + pos = cio_tell(); + cio_init(buf , i*10000); + cio_seek(pos); + } + mj2_write_moov(&movie); + fwrite(buf,cio_tell(),1,mj2file); + + // Ending program + mj2_memory_free(&movie); + free(cp_init.tcps); + if (tcp_init->numlayers > 9) + free(cp.matrice); + for (tileno = 0; tileno < cp.tw * cp.th; tileno++) + free(cp.tcps[tileno].tccps); + free(cp.tcps); + fclose(mj2file); + free(buf); + remove("Compo0"); + remove("Compo1"); + remove("Compo2"); + + //MEMORY LEAK + #ifdef _DEBUG + _CrtDumpMemoryLeaks(); + #endif + //MEM + + return 0; +} + + diff --git a/mj2/MJ2_codec/frames_to_mj2.dsp b/mj2/MJ2_codec/frames_to_mj2.dsp new file mode 100644 index 00000000..e51185a1 --- /dev/null +++ b/mj2/MJ2_codec/frames_to_mj2.dsp @@ -0,0 +1,269 @@ +# Microsoft Developer Studio Project File - Name="frames_to_mj2" - Package Owner=<4> +# Microsoft Developer Studio Generated Build File, Format Version 6.00 +# ** DO NOT EDIT ** + +# TARGTYPE "Win32 (x86) Console Application" 0x0103 + +CFG=frames_to_mj2 - Win32 Debug +!MESSAGE This is not a valid makefile. To build this project using NMAKE, +!MESSAGE use the Export Makefile command and run +!MESSAGE +!MESSAGE NMAKE /f "frames_to_mj2.mak". +!MESSAGE +!MESSAGE You can specify a configuration when running NMAKE +!MESSAGE by defining the macro CFG on the command line. For example: +!MESSAGE +!MESSAGE NMAKE /f "frames_to_mj2.mak" CFG="frames_to_mj2 - Win32 Debug" +!MESSAGE +!MESSAGE Possible choices for configuration are: +!MESSAGE +!MESSAGE "frames_to_mj2 - Win32 Release" (based on "Win32 (x86) Console Application") +!MESSAGE "frames_to_mj2 - Win32 Debug" (based on "Win32 (x86) Console Application") +!MESSAGE + +# Begin Project +# PROP AllowPerConfigDependencies 0 +# PROP Scc_ProjName "" +# PROP Scc_LocalPath "" +CPP=cl.exe +RSC=rc.exe + +!IF "$(CFG)" == "frames_to_mj2 - Win32 Release" + +# PROP BASE Use_MFC 0 +# PROP BASE Use_Debug_Libraries 0 +# PROP BASE Output_Dir "Release" +# PROP BASE Intermediate_Dir "Release" +# PROP BASE Target_Dir "" +# PROP Use_MFC 0 +# PROP Use_Debug_Libraries 0 +# PROP Output_Dir "Release" +# PROP Intermediate_Dir "Release" +# PROP Ignore_Export_Lib 0 +# PROP Target_Dir "" +# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c +# ADD CPP /nologo /W3 /GX /O2 /I "../libopenjpeg" /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /D "DONT_HAVE_GETOPT" /YX /FD /c +# ADD BASE RSC /l 0x809 /d "NDEBUG" +# ADD RSC /l 0x809 /d "NDEBUG" +BSC32=bscmake.exe +# ADD BASE BSC32 /nologo +# ADD BSC32 /nologo +LINK32=link.exe +# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386 +# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386 + +!ELSEIF "$(CFG)" == "frames_to_mj2 - Win32 Debug" + +# PROP BASE Use_MFC 0 +# PROP BASE Use_Debug_Libraries 1 +# PROP BASE Output_Dir "frames_to_mj2___Win32_Debug0" +# PROP BASE Intermediate_Dir "frames_to_mj2___Win32_Debug0" +# PROP BASE Target_Dir "" +# PROP Use_MFC 0 +# PROP Use_Debug_Libraries 1 +# PROP Output_Dir "frames_to_mj2___Win32_Debug0" +# PROP Intermediate_Dir "frames_to_mj2___Win32_Debug0" +# PROP Target_Dir "" +# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c +# ADD CPP /nologo /W3 /Gm /GX /ZI /Od /I "../libopenjpeg" /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /D "DONT_HAVE_GETOPT" /YX /FD /GZ /c +# ADD BASE RSC /l 0x809 /d "_DEBUG" +# ADD RSC /l 0x809 /d "_DEBUG" +BSC32=bscmake.exe +# ADD BASE BSC32 /nologo +# ADD BSC32 /nologo +LINK32=link.exe +# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept +# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept + +!ENDIF + +# Begin Target + +# Name "frames_to_mj2 - Win32 Release" +# Name "frames_to_mj2 - Win32 Debug" +# Begin Group "MJ2" + +# PROP Default_Filter "" +# Begin Group "MJ2 Header Files" + +# PROP Default_Filter "" +# Begin Source File + +SOURCE=.\compat\getopt.h +# End Source File +# Begin Source File + +SOURCE=.\mj2.h +# End Source File +# Begin Source File + +SOURCE=.\mj2_convert.h +# End Source File +# End Group +# Begin Group "MJ2 Source Files" + +# PROP Default_Filter "" +# Begin Source File + +SOURCE=.\frames_to_mj2.c +# End Source File +# Begin Source File + +SOURCE=.\compat\getopt.c +# End Source File +# Begin Source File + +SOURCE=.\mj2.c +# End Source File +# Begin Source File + +SOURCE=.\mj2_convert.c +# End Source File +# End Group +# End Group +# Begin Group "OpenJPEG" + +# PROP Default_Filter "" +# Begin Group "OpenJPEG Header Files" + +# PROP Default_Filter "" +# Begin Source File + +SOURCE=..\libopenjpeg\bio.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\cio.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\dwt.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\fix.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\int.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\j2k.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\jp2.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\jpt.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\mct.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\mqc.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\openjpeg.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\pi.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\raw.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\t1.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\t2.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\tcd.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\tgt.h +# End Source File +# End Group +# Begin Group "OpenJPEG Source Files" + +# PROP Default_Filter "" +# Begin Source File + +SOURCE=..\libopenjpeg\bio.c +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\cio.c +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\dwt.c +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\fix.c +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\int.c +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\j2k.c +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\jp2.c +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\jpt.c +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\mct.c +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\mqc.c +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\pi.c +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\raw.c +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\t1.c +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\t2.c +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\tcd.c +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\tgt.c +# End Source File +# End Group +# End Group +# End Target +# End Project diff --git a/mj2/MJ2_codec/meta_out.c b/mj2/MJ2_codec/meta_out.c new file mode 100644 index 00000000..12c97f35 --- /dev/null +++ b/mj2/MJ2_codec/meta_out.c @@ -0,0 +1,2185 @@ +/* meta_out.c */ +/* Dump MJ2, JP2 metadata (partial so far) to xml file */ +/* Callable from mj2_to_metadata */ +/* Contributed to Open JPEG by Glenn Pearson, contract software developer, U.S. National Library of Medicine. + +The base code in this file was developed by the author as part of a video archiving +project for the U.S. National Library of Medicine, Bethesda, MD. +It is the policy of NLM (and U.S. government) to not assert copyright. + +A non-exclusive copy of this code has been contributed to the Open JPEG project. +Except for copyright, inclusion of the code within Open JPEG for distribution and use +can be bound by the Open JPEG open-source license and disclaimer, expressed elsewhere. +*/ +#include +#include +#include + +#include "mj2.h" +#include + +//MEMORY LEAK +#ifdef _DEBUG +#define _CRTDBG_MAP_ALLOC +#include // Must be included first +#include +#endif +//MEM + +#include /* for time functions */ +#include +#include "meta_out.h" +#include + +jmp_buf j2k_error; +extern j2k_tcp_t j2k_default_tcp; +static BOOL notes = TRUE; +static BOOL sampletables = FALSE; +static BOOL raw = TRUE; +static BOOL derived = TRUE; + +/* Forwards */ +int xml_write_overall_header(FILE *file, FILE *xmlout, mj2_movie_t * movie, unsigned int sampleframe); +int xml_write_moov(FILE *file, FILE *xmlout, mj2_movie_t * movie, unsigned int sampleframe); + +void uint_to_chars(unsigned int value, char* buf); + +void xml_write_trak(FILE *file, FILE *xmlout, mj2_tk_t *track, unsigned int tnum, unsigned int sampleframe); +void xml_write_tkhd(FILE* file, FILE* xmlout, mj2_tk_t *track, unsigned int tnum); +void xml_write_udta(FILE* file, FILE* xmlout, mj2_tk_t *track, unsigned int tnum); +void xml_write_mdia(FILE* file, FILE* xmlout, mj2_tk_t *track, unsigned int tnum); +void xml_write_stbl(FILE* file, FILE* xmlout, mj2_tk_t *track, unsigned int tnum); + +void UnixTimeToFileTime(time_t t, LPFILETIME pft); +void UnixTimeToSystemTime(time_t t, LPSYSTEMTIME pst); +void xml_time_out(FILE* xmlout, time_t t); + +void int16_to_3packedchars(short int value, char* buf); + +void xml_write_moov_udta(FILE* xmlout, mj2_movie_t * movie); +void xml_write_free_and_skip(FILE* xmlout, mj2_movie_t * movie); +void xml_write_uuid(FILE* xmlout, mj2_movie_t * movie); + +int xml_out_frame(FILE* file, FILE* xmlout, mj2_sample_t *sample, unsigned int snum); + +void xml_out_frame_siz(FILE* xmlout, j2k_image_t *img, j2k_cp_t *cp); +void xml_out_frame_cod(FILE* xmlout, j2k_tcp_t *tcp); +void xml_out_frame_coc(FILE* xmlout, j2k_tcp_t *tcp, int numcomps); /* j2k_image_t *img); */ +BOOL same_component_style(j2k_tccp_t *tccp1, j2k_tccp_t *tccp2); +void xml_out_frame_qcd(FILE* xmlout, j2k_tcp_t *tcp); +void xml_out_frame_qcc(FILE* xmlout, j2k_tcp_t *tcp, int numcomps); /* j2k_image_t *img); */ +BOOL same_component_quantization(j2k_tccp_t *tccp1, j2k_tccp_t *tccp2); +void xml_out_frame_rgn(FILE* xmlout, j2k_tcp_t *tcp, int numcomps);/* j2k_image_t *img);*/ +void xml_out_frame_poc(FILE* xmlout, j2k_tcp_t *tcp); +void xml_out_frame_ppm(FILE* xmlout, j2k_cp_t *cp); +void xml_out_frame_ppt(FILE* xmlout, j2k_tcp_t *tcp); +void xml_out_frame_tlm(FILE* xmlout); /* j2k_default_tcp is passed globally */ /* NO-OP. TLM NOT SAVED IN DATA STRUCTURE */ +void xml_out_frame_plm(FILE* xmlout); /* j2k_default_tcp is passed globally */ /* NO-OP. PLM NOT SAVED IN DATA STRUCTURE. opt in main; can be used in conjunction with PLT */ +void xml_out_frame_plt(FILE* xmlout, j2k_tcp_t *tcp); /* NO-OP. PLM NOT SAVED IN DATA STRUCTURE. opt in main; can be used in conjunction with PLT */ +void xml_out_frame_crg(FILE* xmlout); /* j2k_default_tcp is passed globally */ /* opt in main; */ +void xml_out_frame_com(FILE* xmlout, j2k_tcp_t *tcp); /* NO-OP. COM NOT SAVED IN DATA STRUCTURE */ /* opt in main; */ +void xml_out_dump_hex(FILE* xmlout, char *data, int data_len, char* s); +void xml_out_dump_hex_and_ascii(FILE* xmlout, char *data, int data_len, char* s); +void xml_out_frame_jp2h(FILE* xmlout, jp2_struct_t *jp2_struct); +#ifdef NOTYET +/* Shown with cp, extended, as data structure... but it could be a new different one */ +void xml_out_frame_jp2i(FILE* xmlout, j2k_cp_t *cp);/* IntellectualProperty 'jp2i' (no restrictions on location) */ +void xml_out_frame_xml(FILE* xmlout, j2k_cp_t *cp); /* XML 'xml\040' (0x786d6c20). Can appear multiply */ +void xml_out_frame_uuid(FILE* xmlout, j2k_cp_t *cp); /* UUID 'uuid' (top level only) */ +void xml_out_frame_uinf(FILE* xmlout, j2k_cp_t *cp); /* UUIDInfo 'uinf', includes UUIDList 'ulst' and URL 'url\40' */ +void xml_out_frame_unknown_type(FILE* xmlout, j2k_cp_t *cp); +#endif + + +/* ------------------------------------------------------------------------------------------- */ + +void xml_write_init(BOOL n, BOOL t, BOOL r, BOOL d) +{ + /* Init file globals */ + notes = n; + sampletables = t; + raw = r; + derived = d; +} + +int xml_write_struct(FILE* file, FILE *xmlout, mj2_movie_t * movie, unsigned int sampleframe, char* stringDTD) { + + if(stringDTD != NULL) + { + fprintf(xmlout,"\n"); + /* stringDTD is known to start with "SYSTEM " or "PUBLIC " */ + /* typical: SYSTEM mj2_to_metadata.dtd */ + stringDTD[6] = '\0'; /* Break into two strings at space, so quotes can be inserted. */ + fprintf(xmlout,"\n", stringDTD, stringDTD+7); + stringDTD[6] = ' '; /* restore for sake of debugger or memory allocator */ + } else + fprintf(xmlout,"\n"); + + fprintf(xmlout, "\n"); + xml_write_overall_header(file, xmlout, movie, sampleframe); + fprintf(xmlout, ""); + return 0; +} + +/* ------------- */ + +int xml_write_overall_header(FILE *file, FILE *xmlout, mj2_movie_t * movie, unsigned int sampleframe) +{ + int i; + char buf[5]; + buf[4] = '\0'; + + fprintf(xmlout, " \n"); + // Called after structure initialized by mj2_read_ftyp + fprintf(xmlout, " \n"); + uint_to_chars(movie->brand, buf); + fprintf(xmlout, " %s\n", buf); /* 4 character; BR */ + fprintf(xmlout, " %u\n", movie->minversion); /* 4 char; MinV */ + fprintf(xmlout, " \n",movie->num_cl); + for (i = movie->num_cl - 1; i > -1; i--) /* read routine stored in reverse order, so let's undo damage */ + { + uint_to_chars(movie->cl[i], buf); + fprintf(xmlout, " %s\n", buf); /*4 characters, each CLi */ + } + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + xml_write_moov(file, xmlout, movie, sampleframe); + // To come? // This is the container for media data that can also be accessed through track structures, + // so is redundant, and simply not of interest as metadata + // // Allows incremental build up of movie. Probably not in Simple Profile + xml_write_free_and_skip(xmlout, movie); /* NO OP so far */ /* May be a place where user squirrels metadata */ + xml_write_uuid(xmlout, movie); /* NO OP so far */ /* May be a place where user squirrels metadata */ + return 0; +} + +/* ------------- */ + +int xml_write_moov(FILE *file, FILE *xmlout, mj2_movie_t * movie, unsigned int sampleframe) +{ + unsigned int tnum; + mj2_tk_t *track; + + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + if(raw) + fprintf(xmlout, " %u\n", movie->creation_time); + if(notes) + fprintf(xmlout, " \n"); + /* 2082844800 = seconds between 1/1/04 and 1/1/70 */ + /* There's still a time zone offset problem not solved... but spec is ambigous as to whether stored time + should be local or UTC */ + if(derived) { + fprintf(xmlout, " "); + xml_time_out(xmlout, movie->creation_time - 2082844800); + fprintf(xmlout,"\n"); + } + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + if(raw) + fprintf(xmlout, " %u\n", movie->modification_time); + if(derived) { + fprintf(xmlout, " "); + xml_time_out(xmlout, movie->modification_time - 2082844800); + fprintf(xmlout,"\n"); + } + fprintf(xmlout, " \n"); + fprintf(xmlout, " %d\n", movie->timescale); + if(notes) + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); /* Rate to play presentation (default = 0x00010000) */ +#define CURRENTSTRUCT +#ifdef CURRENTSTRUCT + movie->rate = movie->rate << 16; +#endif + if(notes) { + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + } + if(raw) + fprintf(xmlout, " 0x%08x\n", movie->rate); + if(derived) + fprintf(xmlout, " %12.6f\n", (double)movie->rate/(double)0x00010000); +#ifdef CURRENTSTRUCT + if(notes) + fprintf(xmlout, " \n"); + movie->rate = movie->rate >> 16; +#endif + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + if(raw) + fprintf(xmlout, " %u\n", movie->duration); + if(derived) + fprintf(xmlout, " %12.3f\n", (double)movie->duration/(double)movie->timescale); // Make this double later to get fractional seconds + fprintf(xmlout, " \n"); +#ifdef CURRENTSTRUCT + movie->volume = movie->volume << 8; +#endif + fprintf(xmlout, " \n"); + if(notes) { + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + } + if(raw) + fprintf(xmlout, " 0x%04x\n", movie->volume); + if(derived) + fprintf(xmlout, " %6.3f\n", (double)movie->volume/(double)0x0100); + fprintf(xmlout, " \n"); +#ifdef CURRENTSTRUCT + if(notes) + fprintf(xmlout, " \n"); + movie->volume = movie->volume >> 8; +#endif + /* Transformation matrix for video */ + fprintf(xmlout, " \n"); + if(notes) { + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + } + fprintf(xmlout, " 0x%08x\n", movie->trans_matrix[0]); + fprintf(xmlout, " 0x%08x\n", movie->trans_matrix[1]); + fprintf(xmlout, " 0x%08x\n", movie->trans_matrix[2]); + fprintf(xmlout, " 0x%08x\n", movie->trans_matrix[3]); + fprintf(xmlout, " 0x%08x\n", movie->trans_matrix[4]); + fprintf(xmlout, " 0x%08x\n", movie->trans_matrix[5]); + fprintf(xmlout, " 0x%08x\n", movie->trans_matrix[6]); + fprintf(xmlout, " 0x%08x\n", movie->trans_matrix[7]); + fprintf(xmlout, " 0x%08x\n", movie->trans_matrix[8]); + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n", movie->num_vtk); + fprintf(xmlout, " \n", movie->num_stk); + fprintf(xmlout, " %d\n", movie->num_htk); + if(notes) + fprintf(xmlout, " \n"); + /* See Part 3 Amend 2 Section 4.2 for relation of MJ2 to Part 12 Sections 7 and 10 hints */ + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + /* Idea for the future: It would be possible to add code to verify that the file values: + 1) are legal and self-consistent + 2) comply with particular JP2 and/or MJ2 profiles. + This could be reported here as additional XML elements */ + + // Find first video track + tnum = 0; + while (movie->tk[tnum].track_type != 0) + tnum ++; + + track = &(movie->tk[tnum]); + // For now, output info on first video track + xml_write_trak(file, xmlout, track, tnum, sampleframe); + + // to come: // possibly not in Simple Profile + xml_write_moov_udta(xmlout, movie); /* NO OP so far */ /* contains */ + fprintf(xmlout, " \n"); + return 0; +} + +/* --------------- */ + +void uint_to_chars(unsigned int value, char* buf) +{ + /* buf is at least char[5] */ + int i; + for (i = 3; i >= 0; i--) + { + buf[i] = (value & 0x000000ff); + value = (value >> 8); + } + buf[4] = '\0'; /* Precautionary */ +} + +/* ------------- */ + +/* WINDOWS SPECIFIC */ + +void UnixTimeToFileTime(time_t t, LPFILETIME pft) +{ + /* Windows specific. From MS Q167296 */ + /* 'time_t' represents seconds since midnight January 1, 1970 UTC (coordinated universal time). */ + /* 64-bit FILETIME structure represents the number of 100-nanosecond intervals since January 1, 1601 UTC (coordinate universal time). */ + LONGLONG ll; /* LONGLONG is a 64-bit value. */ + ll = Int32x32To64(t, 10000000) + 116444736000000000; + pft->dwLowDateTime = (DWORD)ll; + /* pft->dwLowDateTime = (DWORD)(0x00000000ffffffff & ll); */ + pft->dwHighDateTime = (DWORD)(ll >> 32); +} +// Once the UNIX time is converted to a FILETIME structure, +// other Win32 time formats can be easily obtained by using Win32 functions such +// as FileTimeToSystemTime() and FileTimeToDosDateTime(). + +/* ------------- */ + +void UnixTimeToSystemTime(time_t t, LPSYSTEMTIME pst) +{ + /* Windows specific */ + FILETIME ft; + UnixTimeToFileTime(t, &ft); + FileTimeToLocalFileTime( &ft, &ft ); /* Adjust from UTC to local time zone */ + FileTimeToSystemTime(&ft, pst); +} + +/* ------------- */ + +void xml_time_out(FILE* xmlout, time_t t) +{ + /* Windows specific */ + SYSTEMTIME st; + char szLocalDate[255], szLocalTime[255]; + UnixTimeToSystemTime( t, &st ); + GetDateFormat( LOCALE_USER_DEFAULT, DATE_LONGDATE, &st, NULL, szLocalDate, 255 ); + GetTimeFormat( LOCALE_USER_DEFAULT, 0, &st, NULL, szLocalTime, 255 ); + fprintf(xmlout, "%s %s", szLocalDate, szLocalTime ); +} + +/* END WINDOWS SPECIFIC */ + +/* ------------- */ + +void xml_write_moov_udta(FILE* xmlout, mj2_movie_t * movie) { + /* Compare with xml_write_udta */ +#ifdef NOTYET + /* NO-OP so far. Optional UserData 'udta' (zero or one in moov or each trak) + can contain multiple Copyright 'cprt' with different language codes */ + /* There may be nested non-standard boxes within udta */ + IMAGINE movie->udta, movie->copyright_count, movie->copyright_language[i] (array of 16bit ints), movie->copyright_notice[i] (array of buffers) + PROBABLY ALSO NEED movie->udta_len or special handler for non-standard boxes + char buf[5]; + int i; + + if(movie->udta != 1) + return; /* Not present */ + + fprintf(xmlout, " \n"); + for(i = 0; i < movie->copyright_count; i++) { + fprintf(xmlout, " Instance=\"%d\">\n", i+1); + int16_to_3packedchars((short int)movie->copyright_languages[i], buf); + fprintf(xmlout, " %s\n", buf); /* 3 chars */ + fprintf(xmlout, " %s\n",movie->copyright_notices[i]); + fprintf(xmlout, " \n", i+1); + } + /* TO DO: Non-standard boxes */ + fprintf(xmlout, " \n"); +#endif +} + +void xml_write_free_and_skip(FILE* xmlout, mj2_movie_t * movie) { +#ifdef NOTYET + /* NO-OP so far. There can be zero or more instances of free and/or skip + at the top level of the file. This may be a place where the user squirrel's metadata. + Let's assume unstructured, and do a dump */ + IMAGINE movie->free_and_skip, movie->free_and_skip_count, movie->free_and_skip_content[i] (array of buffers), + movie->free_and_skip_len[i] (array of ints), movie->is_skip[i] (array of BOOL) + int i; + + if(movie->free_and_skip != 1) + return; /* Not present */ + + for(i = 0; i < movie->free_and_skip_count; i++) { + if(movie->is_skip[i]) + fprintf(xmlout, " \n"); + else + fprintf(xmlout, " \n"); + + xml_out_dump_hex_and_ascii(xmlout, movie->free_and_skip_contents[i], movie->free_and_skip_len[i]); + + if(movie->is_skip[i]) + fprintf(xmlout, " \n"); + else + fprintf(xmlout, " \n"); + } +#endif +} + +void xml_write_uuid(FILE* xmlout, mj2_movie_t * movie) { +/* Univeral Unique IDs of 16 bytes. */ +#ifdef NOTYET + /* NO-OP so far. There can be zero or more instances of private uuid boxes in a file. + This function supports the top level of the file, but uuid may be elsewhere [not yet supported]. + This may be a place where the user squirrel's metadata. Let's assume unstructured, and do a dump */ + IMAGINE movie->uuid, movie->uuid_count, movie->uuid_content[i] (array of buffers), + movie->uuid_len[i] (array of ints), movie->uuid_type[i] (array of 17-byte (16+null termination) buffers) + int i; + + if(movie->uuid != 1) + return; /* Not present */ + + for(i = 0; i < movie->uuid_count; i++) { + fprintf(xmlout, " \n", movie->uuid_type[i]); + // See Part III section 5.2.1, 6.1, 6.2 + xml_out_dump_hex_and_ascii(xmlout, movie->uuid_contents[i], movie->uuid_len[i]); + fprintf(xmlout, " \n"); + } +#endif +} + +/* ------------- */ + +void xml_write_trak(FILE* file, FILE* xmlout, mj2_tk_t *track, unsigned int tnum, unsigned int sampleframe) +{ + fprintf(xmlout, " \n", tnum); + xml_write_tkhd(file, xmlout, track, tnum); + // TO DO: TrackReferenceContainer 'tref' just used in hint track + // TO DO: EditListContainer 'edts', contains EditList 'elst' with media-time, segment-duration, media-rate + xml_write_mdia(file, xmlout, track, tnum); + xml_write_udta(file, xmlout, track, tnum); // NO-OP so far. Optional UserData 'udta', can contain multiple Copyright 'cprt' + + if(track->track_type==0) { /* Only do for visual track */ + /* sampleframe is from user option -f. 1 = first frame */ + /* sampleframe of 0 is a user requests: no jp2 header */ + /* Treat out-of-bounds values in the same way */ + if(sampleframe > 0 && sampleframe <= track->num_samples) + { + mj2_sample_t *sample; + unsigned int snum; + + snum = sampleframe-1; + // Someday maybe do a smart range scan... for (snum=0; snum < track->num_samples; snum++){ + // fprintf(stdout,"Frame %d: ",snum+1); + sample = &track->sample[snum]; + if(xml_out_frame(file, xmlout, sample, snum)) + return; /* Not great error handling here */ + } + } + fprintf(xmlout, " \n"); +} + +/* ------------- */ + +void xml_write_tkhd(FILE* file, FILE* xmlout, mj2_tk_t *track, unsigned int tnum) +{ + fprintf(xmlout, " \n"); + if(notes) { + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + } + fprintf(xmlout, " %u\n", track->track_ID); + if(track->track_type==0) /* For visual track */ + { + fprintf(xmlout, " %d\n", track->layer); + if(notes) + fprintf(xmlout," \n"); + } + if(track->track_type!=0) /* volume irrelevant for visual track */ + { +#ifdef CURRENTSTRUCT + track->volume = track->volume << 8; +#endif + fprintf(xmlout, " \n"); + if(notes) { + fprintf(xmlout," \n"); + fprintf(xmlout," \n"); + } + if(raw) + fprintf(xmlout," 0x%04x\n", track->volume); + if(derived) + fprintf(xmlout," %6.3f\n", (double)track->volume/(double)0x0100); + fprintf(xmlout, " \n"); +#ifdef CURRENTSTRUCT + if(notes) + fprintf(xmlout, " \n"); + track->volume = track->volume >> 8; +#endif + } + if(track->track_type==0) + { + /* Transformation matrix for video */ + fprintf(xmlout, " \n"); + if(notes) { + fprintf(xmlout," \n"); + fprintf(xmlout," \n"); + } + fprintf(xmlout, " 0x%08x\n", track->trans_matrix[0]); + fprintf(xmlout, " 0x%08x\n", track->trans_matrix[1]); + fprintf(xmlout, " 0x%08x\n", track->trans_matrix[2]); + fprintf(xmlout, " 0x%08x\n", track->trans_matrix[3]); + fprintf(xmlout, " 0x%08x\n", track->trans_matrix[4]); + fprintf(xmlout, " 0x%08x\n", track->trans_matrix[5]); + fprintf(xmlout, " 0x%08x\n", track->trans_matrix[6]); + fprintf(xmlout, " 0x%08x\n", track->trans_matrix[7]); + fprintf(xmlout, " 0x%08x\n", track->trans_matrix[8]); + fprintf(xmlout, " \n"); + } +#ifdef CURRENTSTRUCT + track->w = track->w << 16; + track->h = track->h << 16; +#endif + if(notes) { + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + } + fprintf(xmlout, " \n"); + if(raw) + fprintf(xmlout, " 0x%08x\n", track->w); + if(derived) + fprintf(xmlout, " %12.6f\n", (double)track->w/(double)0x00010000); /* Rate to play presentation (default = 0x00010000) */ + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + if(raw) + fprintf(xmlout, " 0x%08x\n", track->h); + if(derived) + fprintf(xmlout, " %12.6f\n", (double)track->h/(double)0x00010000); /* Rate to play presentation (default = 0x00010000) */ + fprintf(xmlout, " \n"); +#ifdef CURRENTSTRUCT + if(notes) { + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + } + track->w = track->w >> 16; + track->h = track->h >> 16; +#endif + fprintf(xmlout, " \n"); +} + +/* ------------- */ + +void xml_write_udta(FILE* file, FILE* xmlout, mj2_tk_t *track, unsigned int tnum) { + /* NO-OP so far. Optional UserData 'udta' (zero or one in moov or each trak) + can contain multiple Copyright 'cprt' with different language codes */ + /* There may be nested non-standard boxes within udta */ +#ifdef NOTYET + IMAGINE track->udta, track->copyright_count, track->copyright_language[i] (array of 16bit ints), track->copyright_notice[i] (array of buffers) + PROBABLY ALSO NEED track->udta_len or special handler for non-standard boxes + char buf[5]; + int i; + + if(track->udta != 1) + return; /* Not present */ + + fprintf(xmlout, " \n"); + for(i = 0; i < track->copyright_count; i++) { + fprintf(xmlout, " Instance=\"%d\">\n", i+1); + int16_to_3packedchars((short int)track->copyright_languages[i], buf); + fprintf(xmlout, " %s\n", buf); /* 3 chars */ + fprintf(xmlout, " %s\n",track->copyright_notices[i]); + fprintf(xmlout, " \n", i+1); + } + /* TO DO: Non-standard boxes */ + fprintf(xmlout, " \n"); +#endif +} + +/* ------------- */ + +void xml_write_mdia(FILE* file, FILE* xmlout, mj2_tk_t *track, unsigned int tnum) +{ + char buf[5]; + int i, k; + buf[4] = '\0'; + + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + if(raw) + fprintf(xmlout, " %u\n", track->creation_time); + if(notes) + fprintf(xmlout, " \n"); + /* 2082844800 = seconds between 1/1/04 and 1/1/70 */ + /* There's still a time zone offset problem not solved... but spec is ambigous as to whether stored time + should be local or UTC */ + if(derived) { + fprintf(xmlout, " "); + xml_time_out(xmlout, track->creation_time - 2082844800); + fprintf(xmlout,"\n"); + } + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + if(raw) + fprintf(xmlout, " %u\n", track->modification_time); + if(derived) { + fprintf(xmlout, " "); + xml_time_out(xmlout, track->modification_time - 2082844800); + fprintf(xmlout,"\n"); + } + fprintf(xmlout, " \n"); + fprintf(xmlout, " %d\n", track->timescale); + if(notes) + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + if(raw) + fprintf(xmlout, " %u\n", track->duration); + if(derived) + fprintf(xmlout, " %12.3f\n", (double)track->duration/(double)track->timescale); // Make this double later to get fractional seconds + fprintf(xmlout, " \n"); + int16_to_3packedchars((short int)track->language, buf); + fprintf(xmlout, " %s\n", buf); /* 3 chars */ + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + switch(track->track_type) + { + case 0: + fprintf(xmlout, " video media track\n"); break; + case 1: + fprintf(xmlout, " Sound\n"); break; + case 2: + fprintf(xmlout, " Hint\n"); break; + } + if(notes) { + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + } + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + switch(track->track_type) + { + case 0: + fprintf(xmlout, " \n"); + fprintf(xmlout, " 0x%02x\n", track->graphicsmode); + if(notes) { + fprintf(xmlout," \n"); + fprintf(xmlout," \n"); + fprintf(xmlout," \n"); + fprintf(xmlout," \n"); +/* fprintf(xmlout," \n"); This was evidently dropped upon amendment */ + fprintf(xmlout," \n"); + fprintf(xmlout," \n"); + } + fprintf(xmlout, " \n"); + fprintf(xmlout, " 0x%02x\n", track->opcolor[0]); + fprintf(xmlout, " 0x%02x\n",track->opcolor[1]); + fprintf(xmlout, " 0x%02x\n",track->opcolor[2]); + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + break; + case 1: + fprintf(xmlout, " \n"); +#ifdef CURRENTSTRUCT + track->balance = track->balance << 8; +#endif + fprintf(xmlout, " \n"); + if(notes) { + fprintf(xmlout," \n"); + fprintf(xmlout," \n"); + fprintf(xmlout," \n"); + } + if(raw) + fprintf(xmlout," 0x%04x\n", track->balance); + if(derived) + fprintf(xmlout," %6.3f\n", (double)track->balance/(double)0x0100); + fprintf(xmlout, " \n"); +#ifdef CURRENTSTRUCT + if(notes) + fprintf(xmlout," \n"); + track->balance = track->balance >> 8; +#endif + fprintf(xmlout, " \n"); + break; + case 2: + fprintf(xmlout, " \n"); + fprintf(xmlout, " %d\n", track->maxPDUsize); + if(notes) + fprintf(xmlout," \n"); + fprintf(xmlout, " %d\n", track->avgPDUsize); + if(notes) + fprintf(xmlout," \n"); + fprintf(xmlout, " %d\n", track->maxbitrate); + if(notes) + fprintf(xmlout," \n"); + fprintf(xmlout, " %d\n", track->avgbitrate); + if(notes) + fprintf(xmlout," \n"); + fprintf(xmlout, " %d\n", track->slidingavgbitrate); + if(notes) + fprintf(xmlout," \n"); + fprintf(xmlout, " \n"); + break; + } + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n", track->num_url, track->num_urn); // table w. flags, URLs, URNs + // Data structure does not distinguish between single URL, single URN, or DREF table or URLs & URNs. + // We could infer those, but for now just present everything as a DREF table. + if(notes) + fprintf(xmlout, " \n"); + for(k = 0; k < track->num_url; k++) { + fprintf(xmlout, " \n"); // table w. flags, URLs, URNs + if(notes) + fprintf(xmlout," \n"); + for(i = 0; i < 4; i++) { + uint_to_chars(track->url[track->num_url].location[i], buf); + fprintf(xmlout, " %s\n"); + } + fprintf(xmlout, " \n"); // table w. flags, URLs, URNs + } + for(k = 0; k < track->num_urn; k++) { + fprintf(xmlout," \n"); // table w. flags, URLs, URNs + // Only the first 16 bytes are recorded in the data structure currently. + if(notes) + fprintf(xmlout," \n"); + fprintf(xmlout, " "); + for(i = 0; i < 4; i++) { + uint_to_chars(track->urn[track->num_urn].name[i], buf); + fprintf(xmlout,"%s", buf); + } + fprintf(xmlout, "\n"); + fprintf(xmlout, " "); + for(i = 0; i < 4; i++) { + uint_to_chars(track->urn[track->num_urn].location[i], buf); + fprintf(xmlout,"%s"); + } + fprintf(xmlout, "\n"); + fprintf(xmlout, " \n"); + } + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + + xml_write_stbl(file, xmlout, track, tnum); /* SampleTable */ + + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); +} + +/* ------------- */ + +void xml_write_stbl(FILE* file, FILE* xmlout, mj2_tk_t *track, unsigned int tnum) +{ + char buf[5], buf33[33]; + int i, len; + buf[4] = '\0'; + + fprintf(xmlout, " \n"); + if(notes) + fprintf(xmlout, " \n"); + switch(track->track_type) + { + case 0: + // There could be multiple instances of this, but "entry_count" is just a local at read-time. + // And it's used wrong, too, as count of just visual type, when it's really all 3 types. + // This is referred to as "smj2" within mj2.c + fprintf(xmlout, " \n"); + if(notes) { + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + } + /* No shifting required. If CURRENTSTRUCT gets changed, then may need to revisit treatment of these */ + fprintf(xmlout, " %d\n", track->w); + fprintf(xmlout, " %d\n", track->h); +// Horizresolution and vertresolution don't require shifting, already stored right in CURRENTSTRUCT + if(notes) { + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + } + fprintf(xmlout, " \n"); + if(raw) + fprintf(xmlout, " 0x%08x\n", track->horizresolution); + if(derived) + fprintf(xmlout, " %12.6f\n", (double)track->horizresolution/(double)0x00010000); /* Rate to play presentation (default = 0x00010000) */ + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + if(raw) + fprintf(xmlout, " 0x%08x\n", track->vertresolution); + if(derived) + fprintf(xmlout, " %12.6f\n", (double)track->vertresolution/(double)0x00010000); /* Rate to play presentation (default = 0x00010000) */ + fprintf(xmlout, " \n"); + + buf33[0] = '\0'; + for(i = 0; i < 8; i++) { + uint_to_chars((unsigned int)track->compressorname[i], buf); + strcat(buf33, buf); /* This loads up (4 * 8) + 1 chars, but trailing ones are usually junk */ + } + len = (int)buf33[0]; /* First byte has string length in bytes. There may be garbage beyond it. */ + buf33[len+1] = '\0'; /* Suppress it */ + fprintf(xmlout, " %s\n", buf33+1); /* Start beyond first byte */ + if(notes) { + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + } + fprintf(xmlout, " 0x%02x\n",track->depth); + if(notes) { + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + } + + xml_out_frame_jp2h(xmlout, &(track->jp2_struct)); /* JP2 Header */ + + /* Following subboxes are optional */ + fprintf(xmlout, " \n"); + fprintf(xmlout, " %d\n", (unsigned int)track->fieldcount); /* uchar as 1 byte uint */ + if(notes) + fprintf(xmlout, " \n"); + fprintf(xmlout, " %d\n", (unsigned int)track->fieldorder); /* uchar as 1 byte uint */ + if(notes) { + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + } + fprintf(xmlout, " \n"); + + fprintf(xmlout, " \n",track->num_br); + for (i = 0; i < track->num_br; i++) /* read routine stored in reverse order, so let's undo damage */ + { + uint_to_chars(track->br[i], buf); + fprintf(xmlout, " %s\n", buf); /*4 characters, each CLi */ + } + fprintf(xmlout, " \n"); + + fprintf(xmlout, " \n",track->num_jp2x); + for (i = 0; i < track->num_jp2x; i++) + { // We'll probably need better formatting than this + fprintf(xmlout, " 0x%02x\n", track->jp2xdata[i]); /* Each entry is single byte */ + } + fprintf(xmlout, " \n"); + + fprintf(xmlout, " \n"); /* These values are all 1 byte */ + if(notes) + fprintf(xmlout, " \n"); + fprintf(xmlout, " %d\n", track->hsub); + fprintf(xmlout, " %d\n", track->vsub); + fprintf(xmlout, " %d\n", track->hoff); + fprintf(xmlout, " %d\n", track->voff); + if(notes) { + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + } + fprintf(xmlout, " \n"); /* These values are all 1 byte */ + + fprintf(xmlout, " \n"); /* Part III Appx. 2 */ + fprintf(xmlout, " %u\n", (unsigned int)track->or_fieldcount); /* uchar as 1-byte uint */ + if(notes) + fprintf(xmlout, " \n"); + fprintf(xmlout, " %u\n", (unsigned int)track->or_fieldorder); /* uchar as 1-byte uint */ + if(notes) { + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + } + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + break; + case 1: case 2: + if(notes) + fprintf(xmlout, " \n"); break; + } + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + fprintf(xmlout, " %d\n", track->num_samples); + if(notes) + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n", track->num_tts); + for (i = 0; i < track->num_tts; i++) { + fprintf(xmlout, " \n", + i+1, track->tts[i].sample_count, track->tts[i].sample_delta); + } + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + + fprintf(xmlout, " \n", track->num_samplestochunk); + for (i = 0; i < track->num_samplestochunk; i++) { + fprintf(xmlout, " %u\n",track->sampletochunk[i].first_chunk); /* 4 bytes */ + fprintf(xmlout, " %u\n",track->sampletochunk[i].samples_per_chunk); /* 4 bytes */ + fprintf(xmlout, " %u\n",track->sampletochunk[i].sample_descr_idx); /* 4 bytes */ + } + fprintf(xmlout, " \n"); + // After reading this info in, track->num_chunks is calculated and a decompressed table established internally. + + fprintf(xmlout, " \n"); + if(track->same_sample_size) { + // all values in track->sample[i].sample_size are equal. Grab the first one. + fprintf(xmlout, " %u\n", track->sample[0].sample_size); + if(notes) { + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + } + } else { + fprintf(xmlout, " 0\n"); + if(notes) + if(sampletables) + fprintf(xmlout," \n"); + else + fprintf(xmlout," \n"); + fprintf(xmlout, " %u\n", track->num_samples); + if(sampletables) + for (i = 0; i < (int)track->num_samples; i++) { + fprintf(xmlout, " %u\n", i+1, track->sample[i].sample_size); + } + } + fprintf(xmlout, " \n"); + + fprintf(xmlout, " \n"); + // Structure not yet - Variant ChunkLargeOffset 'co64' + fprintf(xmlout, " %u\n", track->num_chunks); + if(notes) { + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + } + if(sampletables) + for (i = 0; i < (int)track->num_chunks; i++) + fprintf(xmlout, " %u\n", i+1, track->chunk[i].offset); + fprintf(xmlout, " \n"); + + fprintf(xmlout, " \n"); +} + +/* ------------- */ + +int xml_out_frame(FILE* file, FILE* xmlout, mj2_sample_t *sample, unsigned int snum) +{ + j2k_image_t img; + j2k_cp_t cp; + int i; + int numcomps; + unsigned char* frame_codestream; +/* char xmloutname[50]; */ + + frame_codestream = (unsigned char*) malloc (sample->sample_size-8); /* Skipping JP2C marker */ + if(frame_codestream == NULL) + return 1; + + fseek(file,sample->offset+8,SEEK_SET); + fread(frame_codestream,sample->sample_size-8,1, file); /* Assuming that jp and ftyp markers size do */ + /* Decode J2K to image: */ + if (!j2k_decode(frame_codestream, sample->sample_size-8, &img, &cp)) { + free(frame_codestream); +#ifndef NO_PACKETS_DECODING + for (i=0; i\n", snum+1); + fprintf(xmlout, " \n"); + /* There can be multiple codestreams; a particular image is entirely within a single codestream */ + /* TO DO: A frame can be represented by two I-guess-contigious codestreams if its interleaved. */ + fprintf(xmlout, " \n"); + /* "cp" stands for "coding parameter"; "tcp" is tile coding parameters, "tccp" is tile-component coding parameters */ + xml_out_frame_siz(xmlout, &img, &cp); /* reqd in main */ + xml_out_frame_cod(xmlout, &j2k_default_tcp); /* reqd in main */ + xml_out_frame_coc(xmlout, &j2k_default_tcp, numcomps); /* opt in main, at most 1 per component */ + xml_out_frame_qcd(xmlout, &j2k_default_tcp); /* reqd in main */ + xml_out_frame_qcc(xmlout, &j2k_default_tcp, numcomps); /* opt in main, at most 1 per component */ + xml_out_frame_rgn(xmlout, &j2k_default_tcp, numcomps); /* opt, at most 1 per component */ + xml_out_frame_poc(xmlout, &j2k_default_tcp); /* opt (but reqd in main or tile for any progression order changes) */ + /* Next four get j2k_default_tcp passed globally: */ +#ifdef SUPPRESS_FOR_NOW + xml_out_frame_ppm(xmlout, &cp); /* opt (but either PPM or PPT [distributed in tile headers] or codestream packet header reqd) */ +#endif + xml_out_frame_tlm(xmlout); /* NO-OP. TLM NOT SAVED IN DATA STRUCTURE */ /* opt */ + xml_out_frame_plm(xmlout); /* NO-OP. PLM NOT SAVED IN DATA STRUCTURE */ /* opt in main; can be used in conjunction with PLT */ + xml_out_frame_crg(xmlout); /* NO-OP. CRG NOT SAVED IN DATA STRUCTURE */ /* opt in main; */ + xml_out_frame_com(xmlout, &j2k_default_tcp); /* NO-OP. COM NOT SAVED IN DATA STRUCTURE */ /* opt in main; */ + + fprintf(xmlout, " \n"); + + /* TO DO: all the tile headers (sigh) */ + fprintf(xmlout, " \n", cp.tileno_size); /* size of the vector tileno */ + for(i = 0; i < cp.tileno_size; i++) { /* I think cp.tileno_size will be same number as (cp.tw * cp.th) or as global j2k_curtileno */ + // Standard seems to use zero-based # for tile-part. + fprintf(xmlout, " \n", i, cp.tileno[i]); /* ID number of the tiles present in the codestream */ + fprintf(xmlout, " \n"); + /* All markers in tile-part headers (between SOT and SOD) are optional, unless structure requires. */ + if(i == 0) { + xml_out_frame_cod(xmlout, &(cp.tcps[i])); /* No more than 1 per tile */ + xml_out_frame_coc(xmlout, &(cp.tcps[i]), numcomps); /* No more than 1 per component */ + xml_out_frame_qcd(xmlout, &(cp.tcps[i])); /* No more than 1 per tile */ + xml_out_frame_qcc(xmlout, &(cp.tcps[i]), numcomps); /* No more than 1 per component */ + xml_out_frame_rgn(xmlout, &(cp.tcps[i]), numcomps); /* No more than 1 per component */ + } + xml_out_frame_poc(xmlout, &(cp.tcps[i])); /* Reqd only if any progression order changes different from main POC */ +#ifdef SUPPRESS_FOR_NOW + xml_out_frame_ppt(xmlout, &(cp.tcps[i])); /* Either PPT [distributed in tile headers] or PPM or codestream packet header reqd. */ +#endif + xml_out_frame_plt(xmlout, &(cp.tcps[i])); /* NO-OP. PLT NOT SAVED IN DATA STRUCTURE */ /* Can be used in conjunction with main's PLM */ + xml_out_frame_com(xmlout, &(cp.tcps[i])); /* NO-OP. COM NOT SAVED IN DATA STRUCTURE */ + /* j2k_tcp_t * cp.tcps; "tile coding parameters" */ + /* Maybe not: fprintf(xmlout, " <>%d, cp.matrice[i]; */ /* Fixed layer */ + fprintf(xmlout, " \n"); + if(notes) + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + } + fprintf(xmlout, " \n"); /* size of the vector tileno */ + +#ifdef NOTYET + IMAGINE the cp object has data to support the following... but we could use an new different data structure instead + /* I'm unclear if the span of the original fread(frame_codestream...) included the following items if they're trailing. */ + /* ALSO TO DO, BUT DATA STRUCTURE DOESN'T HANDLE YET: boxes (anywhere in file except before the Filetype box): */ + xml_out_frame_jp2i(xmlout, &cp); /* IntellectualProperty 'jp2i' (no restrictions on location) */ + xml_out_frame_xml(xmlout, &cp); /* XML 'xml\040' (0x786d6c20). Can appear multiply */ + xml_out_frame_uuid(xmlout, &cp); /* UUID 'uuid' (top level only) */ + xml_out_frame_uinf(xmlout, &cp); /* UUIDInfo 'uinf', includes UUIDList 'ulst' and URL 'url\40' */ +#endif + + fprintf(xmlout, " \n"); + + /* Extra commentary: */ + if(notes) { + fprintf(xmlout, " \n"); + if (((img.numcomps == 3) && (img.comps[0].dx == img.comps[1].dx / 2) + && (img.comps[0].dx == img.comps[2].dx / 2 ) && (img.comps[0].dx == 1)) + || (img.numcomps == 1)) { + fprintf(xmlout, " \n"); + } + else if ((img.numcomps == 3) && + (img.comps[0].dx == 1) && (img.comps[1].dx == 1)&& + (img.comps[2].dx == 1)) {// If YUV 4:4:4 input --> to bmp + fprintf(xmlout, " \n"); + } + else { + fprintf(xmlout, " \n"); + } + } + +#ifndef NO_PACKETS_DECODING + for (i=0; i= 0; i--) + { + buf[i] = (value & 0x001f) + 0x60; + value = (value >>5); + } + buf[3] = '\0'; +} + +/* ------------- */ + +void xml_out_frame_siz(FILE* xmlout, j2k_image_t *img, j2k_cp_t *cp) +{ + j2k_comp_t *comp; + int i; + + fprintf(xmlout, " \n"); + // This is similar to j2k.c's j2k_dump_image. + // Not of interest: Lsiz, Rsiz + fprintf(xmlout, " %d\n", img->x1); + fprintf(xmlout, " %d\n", img->y1); + if(notes) + fprintf(xmlout, " \n"); + fprintf(xmlout, " %d\n", img->x0); + fprintf(xmlout, " %d\n", img->y0); + if(notes) + fprintf(xmlout, " \n"); + fprintf(xmlout, " %d\n", cp->tdx); + fprintf(xmlout, " %d\n", cp->tdy); + if(notes) + fprintf(xmlout, " \n"); + fprintf(xmlout, " %d\n", cp->tx0); + fprintf(xmlout, " %d\n", cp->ty0); + if(notes) + fprintf(xmlout, " \n"); + fprintf(xmlout, " %d\n", img->numcomps); + if(notes) { + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + //fprintf(xmlout," \n"); + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + } + + for (i = 0; i < img->numcomps; i++) {/* image-components */ + comp = &(img->comps[i]); + fprintf(xmlout, " \n", i+1); + fprintf(xmlout, " \n"); + if(raw) + fprintf(xmlout," 0x%02x\n", (comp->sgnd << 7) & (comp->prec - 1)); + if(derived) { + fprintf(xmlout," %d\n", comp->sgnd); + fprintf(xmlout," %d\n", comp->prec); + } + fprintf(xmlout, " \n"); + fprintf(xmlout, " %d\n", comp->dx); + fprintf(xmlout, " %d\n", comp->dy); + fprintf(xmlout, " %d\n", comp->w); + fprintf(xmlout, " %d\n", comp->h); + /* Rest of these aren't calculated when SIZ is read: + fprintf(xmlout, " %d\n", comp->x0); + fprintf(xmlout, " %d\n", comp->y0); + if(notes) + fprintf(xmlout," \n"); + fprintf(xmlout, " %d\n", comp->bpp); + fprintf(xmlout, " %d\n", comp->resno_decoded); */ + // SUPPRESS: n/a to mj2_to_metadata. fprintf(xmlout," %dfactor); + /* factor = number of division by 2 of the out image compare to the original size of image */ + // TO DO comp->data: int *data; /* image-component data */ + + fprintf(xmlout, " \n"); + } + fprintf(xmlout, " \n"); +} + +/* ------------- */ + +void xml_out_frame_cod(FILE* xmlout, j2k_tcp_t *tcp) +{ +/* Could be called with tcp = &j2k_default_tcp; +/* Or, for tile-part header, with &j2k_cp->tcps[j2k_curtileno] +/* Alignment for main:" < < < < To help maintain xml pretty-printing */ +/* Alignment for tile:" < < < To help maintain xml pretty-printing */ + j2k_tccp_t *tccp; + int i; + char spaces[13] = " "; /* 12 spaces if tilepart*/ + char* s = spaces; + if(tcp == &j2k_default_tcp) { + s++;s++; /* shorten s to 10 spaces if main */ + } + tccp = &(tcp->tccps[0]); + + fprintf(xmlout, "%s\n",s); /* Required in main header */ + /* Not retained or of interest: Lcod */ + fprintf(xmlout, "%s 0x%02x\n", s, tcp->csty); /* 1 byte */ + if(notes) { + fprintf(xmlout, "%s \n",s); + fprintf(xmlout, "%s \n",s); + fprintf(xmlout, "%s \n",s); + fprintf(xmlout, "%s \n",s); + fprintf(xmlout, "%s \n",s); + } + fprintf(xmlout, "%s \n",s); + fprintf(xmlout, "%s %d\n", s, tcp->prg); /* 1 byte, SGcod (A) */ + if(notes) { + fprintf(xmlout, "%s \n",s); + fprintf(xmlout, "%s \n",s); + fprintf(xmlout, "%s \n",s); + } + fprintf(xmlout, "%s %d\n", s, tcp->numlayers); /* 2 bytes, SGcod (B) */ + fprintf(xmlout, "%s %d\n", s, tcp->mct); /* 1 byte, SGcod (C). More or less boolean */ + if(notes) + fprintf(xmlout, "%s \n",s); + fprintf(xmlout, "%s \n",s); + /* This code will compile only if declaration of j2k_default_tcp is changed from static (to implicit extern) in j2k.c */ + fprintf(xmlout, "%s \n",s); + /* Internal data structure tccp defines separate defaults for each component, but they all get the same values */ + /* So we only have to report the first component's values here. */ + /* Compare j2k_read_cox(...) */ + fprintf(xmlout, "%s %d\n", s, tccp->numresolutions - 1); /* 1 byte, SPcox (D) */ + fprintf(xmlout, "%s %d\n", s, tccp->cblkw - 2); /* 1 byte, SPcox (E) */ + fprintf(xmlout, "%s %d\n", s, tccp->cblkh - 2); /* 1 byte, SPcox (F) */ + if(notes) { + fprintf(xmlout, "%s \n",s); + fprintf(xmlout, "%s \n", s); + } + fprintf(xmlout, "%s 0x%02x\n", s, tccp->cblksty); /* 1 byte, SPcox (G) */ + if(notes) { + fprintf(xmlout, "%s \n",s); + fprintf(xmlout, "%s \n",s); + fprintf(xmlout, "%s \n",s); + fprintf(xmlout, "%s \n",s); + fprintf(xmlout, "%s \n",s); + fprintf(xmlout, "%s \n",s); + fprintf(xmlout, "%s \n",s); + } + fprintf(xmlout, "%s %d\n", s, tccp->qmfbid); /* 1 byte, SPcox (H) */ + if(notes) + fprintf(xmlout, "%s \n",s); + if (tccp->csty & J2K_CP_CSTY_PRT) { + fprintf(xmlout, "%s \n",s); /* 1 byte, SPcox (I_i) */ + if(notes) + fprintf(xmlout, "%s \n",s); + for (i = 0; i < tccp->numresolutions; i++) { + fprintf(xmlout, "%s \n", s, i); + if(raw) + fprintf(xmlout,"%s 0x%02x\n", s, (tccp->prch[i] << 4) | tccp->prcw[i]); /* packed into 1 byte, SPcox (G) */ + if(derived) { + fprintf(xmlout,"%s %d\n", s, tccp->prcw[i]); + fprintf(xmlout,"%s %d\n", s, tccp->prch[i]); + } + fprintf(xmlout, "%s \n", s, i); + } + fprintf(xmlout, "%s \n",s); /* 1 byte, SPcox (I_i) */ + } + fprintf(xmlout, "%s \n",s); + fprintf(xmlout, "%s\n",s); +} + +/* ------------- */ + +void xml_out_frame_coc(FILE* xmlout, j2k_tcp_t *tcp, int numcomps) /* Optional in main & tile-part headers */ +{ +/* Uses global j2k_default_tcp */ + j2k_tccp_t *tccp, *firstcomp_tccp; + int i, compno; + char spaces[13] = " "; /* 12 spaces if tilepart*/ + char* s = spaces; + if(tcp == &j2k_default_tcp) { + s++;s++; /* shorten s to 10 spaces if main */ + } + + firstcomp_tccp = &(tcp->tccps[0]); + /* Internal data structure tccp defines separate defaults for each component, set from main */ + /* default, then selectively overwritten. */ + /* Compare j2k_read_cox(...) */ + /* We don't really know which was the default, and which were not */ + /* Let's pretend that [0] is the default and all others are not */ + if(notes) { + fprintf(xmlout, "%s\n", s); + if(tcp == &j2k_default_tcp) + fprintf(xmlout, "%s\n", s); + else + fprintf(xmlout, "%s\n", s); + } + for (compno = 1; compno < numcomps; compno++) /* spec says components are zero-based */ + { + tccp = &tcp->tccps[compno]; + if(same_component_style(firstcomp_tccp, tccp)) + continue; + +/* Alignments: " < < < < < To help maintain xml pretty-printing */ + fprintf(xmlout, "%s\n", s); /* Optional in main header, at most 1 per component */ + if(notes) + fprintf(xmlout, "%s \n", s); + /* Overrides the main COD for the specific component */ + /* Not retained or of interest: Lcod */ + fprintf(xmlout, "%s 0x%02x\n", s, tccp->csty); /* 1 byte */ + if(notes) { + fprintf(xmlout, "%s \n", s); + fprintf(xmlout, "%s \n", s); + } + fprintf(xmlout, "%s %d\n", s, compno); /* 1 or 2 bytes */ + /* Unfortunately compo isn't retained in j2k_read_coc: compno = cio_read(j2k_img->numcomps <= 256 ? 1 : 2); /* Ccoc */ + /*if(j2k_img_numcomps <=256) + component is 1 byte + else + compno is 2 byte */ + + /* This code will compile only if declaration of j2k_default_tcp is changed from static (to implicit extern) in j2k.c */ + fprintf(xmlout, "%s \n", s); + fprintf(xmlout, "%s %d\n", s, tccp->numresolutions - 1); /* 1 byte, SPcox (D) */ + fprintf(xmlout, "%s %d\n", s, tccp->cblkw - 2); /* 1 byte, SPcox (E) */ + fprintf(xmlout, "%s %d\n", s, tccp->cblkh - 2); /* 1 byte, SPcox (F) */ + if(notes) { + fprintf(xmlout, "%s \n", s); + fprintf(xmlout, "%s \n", s); + } + fprintf(xmlout, "%s 0x%02x\n", s, tccp->cblksty); /* 1 byte, SPcox (G) */ + if(notes) { + fprintf(xmlout, "%s \n", s); + fprintf(xmlout, "%s \n", s); + fprintf(xmlout, "%s \n", s); + fprintf(xmlout, "%s \n", s); + fprintf(xmlout, "%s \n", s); + fprintf(xmlout, "%s \n", s); + fprintf(xmlout, "%s \n", s); + } + fprintf(xmlout, "%s %d\n", s, tccp->qmfbid); /* 1 byte, SPcox (H) */ + if(notes) + fprintf(xmlout, "%s \n", s); + if (tccp->csty & J2K_CP_CSTY_PRT) { + fprintf(xmlout, "%s \n", s); /* 1 byte, SPcox (I_i) */ + if(notes) + fprintf(xmlout, "%s \n", s); + for (i = 0; i < tccp->numresolutions-1; i++) { /* subtract 1 to get # of decomposition levels */ + fprintf(xmlout, "%s \n", s, i); + if(raw) + fprintf(xmlout,"%s 0x%02x\n", s, (tccp->prch[i] << 4) | tccp->prcw[i]); /* packed into 1 byte, SPcox (G) */ + if(derived) { + fprintf(xmlout,"%s %d\n", s, tccp->prcw[i]); + fprintf(xmlout,"%s %d\n", s, tccp->prch[i]); + } + fprintf(xmlout, "%s \n", s, i); + } + fprintf(xmlout, "%s \n", s); /* 1 byte, SPcox (I_i) */ + } + fprintf(xmlout, "%s \n", s); + fprintf(xmlout, "%s\n", s); + } +} + +/* ------------- */ + +BOOL same_component_style(j2k_tccp_t *tccp1, j2k_tccp_t *tccp2) +{ + int i; + + if(tccp1->numresolutions != tccp2->numresolutions) + return FALSE; + if(tccp1->cblkw != tccp2->cblkw) + return FALSE; + if(tccp1->cblkh != tccp2->cblkh) + return FALSE; + if(tccp1->cblksty != tccp2->cblksty) + return FALSE; + if(tccp1->csty != tccp2->csty) + return FALSE; + + if (tccp1->csty & J2K_CP_CSTY_PRT) { + for (i = 0; i < tccp1->numresolutions; i++) { + if(tccp1->prcw[i] != tccp2->prcw[i] || tccp1->prch[i] != tccp2->prch[i]) + return FALSE; + } + } + return TRUE; +} + +/* ------------- */ + +void xml_out_frame_qcd(FILE* xmlout, j2k_tcp_t *tcp) +{ + /* This code will compile only if declaration of j2k_default_tcp is changed from static (to implicit extern) in j2k.c */ + j2k_tccp_t *tccp; + int bandno, numbands; + char spaces[13] = " "; /* 12 spaces if tilepart*/ + char* s = spaces; + if(tcp == &j2k_default_tcp) { + s++;s++; /* shorten s to 10 spaces if main */ + } + + /* Compare j2k_read_qcx */ + fprintf(xmlout, "%s\n", s); /* Required in main header, single occurrence */ + tccp = &(tcp->tccps[0]); + /* Not retained or of interest: Lqcd */ + fprintf(xmlout, "%s \n", s); /* 1 byte */ + if(notes) + fprintf(xmlout, "%s \n", s); + if(raw) + fprintf(xmlout, "%s 0x%02x\n", s, (tccp->numgbits) << 5 | tccp->qntsty); + if(derived) + fprintf(xmlout, "%s %d\n", s, tccp->qntsty); + if(notes) { + fprintf(xmlout, "%s \n", s); + fprintf(xmlout, "%s \n", s); + fprintf(xmlout, "%s \n", s); + fprintf(xmlout, "%s \n", s); + } + if(derived) + fprintf(xmlout, "%s %d\n", s, tccp->numgbits); + if(notes) + fprintf(xmlout, "%s \n", s); + fprintf(xmlout, "%s \n", s); + + /* Problem: numbands in some cases is calculated from len, which is not retained or available here at this time */ + /* So we'll just dump all internal values */ + /* We could calculate it, but I'm having trouble believing the length equations in the standard */ + + fprintf(xmlout, "%s \n", s); + switch(tccp->qntsty) { + case J2K_CCP_QNTSTY_NOQNT: /* no quantization */ + /* This is what standard says, but I don't believe it: len = 4 + (3*decomp); */ + numbands = J2K_MAXBANDS; /* should be: numbands = len - 1; */ + /* Better: IMAGINE numbands = tccp->stepsize_numbands; */ + /* Instead look for first zero exponent, quit there. Adequate? */ + fprintf(xmlout, "%s \n", s); + if(notes) { + fprintf(xmlout, "%s \n", s); + fprintf(xmlout, "%s \n", s); + fprintf(xmlout, "%s \n", s); + fprintf(xmlout, "%s \n", s); + } + for (bandno = 0; bandno < numbands; bandno++) { + if(tccp->stepsizes[bandno].expn == 0) + break; /* Remove when we have real numbands */ + fprintf(xmlout, "%s \n", s, bandno); + if(raw) + fprintf(xmlout,"%s 0x%02x\n", s, tccp->stepsizes[bandno].expn << 3); + if(derived) + fprintf(xmlout,"%s %d\n", s, tccp->stepsizes[bandno].expn); + fprintf(xmlout, "%s \n", s); + } + fprintf(xmlout, "%s \n", s); + break; + case J2K_CCP_QNTSTY_SIQNT: /* scalar quantization derived */ + /* This is what standard says. Should I believe it:: len = 5; + /* numbands = 1; */ + fprintf(xmlout, "%s \n", s); + if(notes) + fprintf(xmlout, "%s \n", s); + fprintf(xmlout, "%s \n", s); + if(notes) + fprintf(xmlout, "%s \n", s); + fprintf(xmlout, "%s \n", s); + fprintf(xmlout, "%s \n", s); + fprintf(xmlout, "%s \n", s); + } + + for (bandno = 1; bandno < J2K_MAXBANDS; bandno++) { + if(tccp->stepsizes[bandno].expn == 0) + break; + + fprintf(xmlout, "%s %d\n", s, bandno, tccp->stepsizes[bandno].expn); + } + + fprintf(xmlout, "%s \n", s); + break; + + default: /* J2K_CCP_QNTSTY_SEQNT */ /* scalar quantization expounded */ + /* This is what standard says, but should I believe it: len = 5 + 6*decomp; */ + numbands = J2K_MAXBANDS; /* should be: (len - 1) / 2;*/ + /* Better: IMAGINE numbands = tccp->stepsize_numbands; */ + fprintf(xmlout, "%s \n", s); + if(notes) { + fprintf(xmlout, "%s \n", s); + fprintf(xmlout, "%s \n", s); + fprintf(xmlout, "%s \n", s); + } + for (bandno = 0; bandno < numbands; bandno++) { + if(tccp->stepsizes[bandno].expn == 0 && tccp->stepsizes[bandno].mant == 0) + break; /* Remove when we have real numbands */ + + fprintf(xmlout, "%s \n", s, bandno); + if(raw) + fprintf(xmlout,"%s 0x%02x\n", s, (tccp->stepsizes[bandno].expn << 11) | tccp->stepsizes[bandno].mant); + if(derived) { + fprintf(xmlout,"%s %d\n", s, tccp->stepsizes[bandno].expn); + fprintf(xmlout,"%s %d\n", s, tccp->stepsizes[bandno].mant); + } + fprintf(xmlout, "%s \n", s); + } + fprintf(xmlout, "%s \n", s); + break; + } /* switch */ + fprintf(xmlout, "%s \n", s); + fprintf(xmlout, "%s\n", s); + +/* Alignments: " < < < < < To help maintain xml pretty-printing */ +} + +/* ------------- */ + +void xml_out_frame_qcc(FILE* xmlout, j2k_tcp_t *tcp, int numcomps) +{ +/* Uses global j2k_default_tcp */ + /* This code will compile only if declaration of j2k_default_tcp is changed from static (to implicit extern) in j2k.c */ + j2k_tccp_t *tccp, *firstcomp_tccp; + int bandno, numbands; + int compno; + char spaces[13] = " "; /* 12 spaces if tilepart*/ + char* s = spaces; + if(tcp == &j2k_default_tcp) { + s++;s++; /* shorten s to 10 spaces if main */ + } + + firstcomp_tccp = &(tcp->tccps[0]); + /* Internal data structure tccp defines separate defaults for each component, set from main */ + /* default, then selectively overwritten. */ + /* Compare j2k_read_qcx(...) */ + /* We don't really know which was the default, and which were not */ + /* Let's pretend that [0] is the default and all others are not */ + if(notes) { + fprintf(xmlout, "%s\n", s); + if(tcp == &j2k_default_tcp) + fprintf(xmlout, "%s\n", s); + else + fprintf(xmlout, "%s\n", s); + } + for (compno = 1; compno < numcomps; compno++) /* spec says components are zero-based */ + { + tccp = &(tcp->tccps[compno]); + if(same_component_quantization(firstcomp_tccp, tccp)) + continue; + + /* Compare j2k_read_qcx */ + fprintf(xmlout, "%s\n", s, compno); /* Required in main header, single occurrence */ + tccp = &j2k_default_tcp.tccps[0]; + /* Not retained or perhaps of interest: Lqcd It maybe can be calculated. */ + fprintf(xmlout, "%s \n", s); /* 1 byte */ + if(notes) + fprintf(xmlout, "%s \n", s); + if(raw) + fprintf(xmlout, "%s 0x%02x\n", s, (tccp->numgbits) << 5 | tccp->qntsty); + if(derived) + fprintf(xmlout, "%s %d\n", s, tccp->qntsty); + if(notes) { + fprintf(xmlout, "%s \n", s); + fprintf(xmlout, "%s \n", s); + fprintf(xmlout, "%s \n", s); + fprintf(xmlout, "%s \n", s); + } + if(derived) + fprintf(xmlout, "%s %d\n", s, tccp->numgbits); + if(notes) + fprintf(xmlout, "%s \n", s); + fprintf(xmlout, "%s \n", s); + + /* Problem: numbands in some cases is calculated from len, which is not retained or available here at this time */ + /* So we'll just dump all internal values */ + fprintf(xmlout, "%s \n", s); + switch(tccp->qntsty) { + case J2K_CCP_QNTSTY_NOQNT: + numbands = J2K_MAXBANDS; /* should be: numbands = len - 1; */ + /* Better: IMAGINE numbands = tccp->stepsize_numbands; */ + + /* Instead look for first zero exponent, quit there. Adequate? */ + fprintf(xmlout, "%s \n", s); + if(notes) { + fprintf(xmlout, "%s \n", s); + fprintf(xmlout, "%s \n", s); + fprintf(xmlout, "%s \n", s); + fprintf(xmlout, "%s \n", s); + } + for (bandno = 0; bandno < numbands; bandno++) { + if(tccp->stepsizes[bandno].expn == 0) + break; /* Remove this once we have real numbands */ + fprintf(xmlout, "%s \n", s, bandno); + if(raw) + fprintf(xmlout,"%s 0x%02x\n", s, tccp->stepsizes[bandno].expn << 3); + if(derived) + fprintf(xmlout,"%s %d\n", s, tccp->stepsizes[bandno].expn); + fprintf(xmlout, "%s \n", s); + } + fprintf(xmlout, "%s \n", s); + break; + case J2K_CCP_QNTSTY_SIQNT: + /* numbands = 1; */ + fprintf(xmlout, "%s \n", s); + if(notes) + fprintf(xmlout, "%s \n", s); + fprintf(xmlout, "%s \n", s); + if(notes) + fprintf(xmlout, "%s \n", s); + fprintf(xmlout, "%s \n", s); + fprintf(xmlout, "%s \n", s); + fprintf(xmlout, "%s \n", s); + } + + for (bandno = 1; bandno < J2K_MAXBANDS; bandno++) { + if(tccp->stepsizes[bandno].expn == 0) + break; + + fprintf(xmlout, "%s %d\n", s, bandno, tccp->stepsizes[bandno].expn); + } + fprintf(xmlout, "%s \n", s); + break; + + default: /* J2K_CCP_QNTSTY_SEQNT */ + numbands = J2K_MAXBANDS; /* should be: (len - 1) / 2;*/ + /* Better: IMAGINE numbands = tccp->stepsize_numbands; */ + fprintf(xmlout, "%s \n", s); + if(notes) { + fprintf(xmlout, "%s \n", s); + fprintf(xmlout, "%s \n", s); + fprintf(xmlout, "%s \n", s); + } + for (bandno = 0; bandno < numbands; bandno++) { + if(tccp->stepsizes[bandno].expn == 0 && tccp->stepsizes[bandno].mant == 0) + break; /* Remove this once we have real numbands count */ + fprintf(xmlout, "%s \n", s, bandno); + if(raw) + fprintf(xmlout,"%s 0x%02x\n", s, (tccp->stepsizes[bandno].expn << 11) | tccp->stepsizes[bandno].mant); + if(derived) { + fprintf(xmlout,"%s %d\n", s, tccp->stepsizes[bandno].expn); + fprintf(xmlout,"%s %d\n", s, tccp->stepsizes[bandno].mant); + } + fprintf(xmlout, "%s \n", s); + } + fprintf(xmlout, "%s \n", s); + break; + } /* switch */ + fprintf(xmlout, "%s \n", s); + fprintf(xmlout, "%s\n", s); + } +/* Alignments: " < < < < < To help maintain xml pretty-printing */ +} + +/* ------------- */ + +BOOL same_component_quantization(j2k_tccp_t *tccp1, j2k_tccp_t *tccp2) +{ + int bandno, numbands; + + if(tccp1->qntsty != tccp2->qntsty) + return FALSE; + if(tccp1->numgbits != tccp2->numgbits) + return FALSE; + + switch(tccp1->qntsty) { + case J2K_CCP_QNTSTY_NOQNT: + numbands = J2K_MAXBANDS; /* should be: numbands = len - 1; */ + /* Instead look for first zero exponent, quit there. Adequate? */ + for (bandno = 0; bandno < numbands; bandno++) { + if(tccp1->stepsizes[bandno].expn == 0) + break; + if(tccp1->stepsizes[bandno].expn != tccp2->stepsizes[bandno].expn) + return FALSE; + } + break; + case J2K_CCP_QNTSTY_SIQNT: + /* numbands = 1; */ + if(tccp1->stepsizes[0].expn != tccp2->stepsizes[0].expn || tccp1->stepsizes[0].mant != tccp2->stepsizes[0].mant) + return FALSE; + /* Don't need to check remainder, since they are calculated from [0] */ + break; + + default: /* J2K_CCP_QNTSTY_SEQNT */ + numbands = J2K_MAXBANDS; /* should be: (len - 1) / 2;*/ + /* This comparison may cause us problems with trailing junk values. */ + for (bandno = 0; bandno < numbands; bandno++) { + if(tccp1->stepsizes[bandno].expn != tccp2->stepsizes[bandno].expn || tccp1->stepsizes[bandno].mant != tccp2->stepsizes[bandno].mant); + return FALSE; + } + break; + } /* switch */ + return TRUE; +} + +/* ------------- */ + +void xml_out_frame_rgn(FILE* xmlout, j2k_tcp_t *tcp, int numcomps) +{ + int compno, SPrgn; + /* MJ2 files can have regions of interest if hybridized with JPX Part II */ + char spaces[13] = " "; /* 12 spaces if tilepart*/ + char* s = spaces; + if(tcp == &j2k_default_tcp) { + s++;s++; /* shorten s to 10 spaces if main */ + } + + for(compno = 0; compno < numcomps; compno++) { + SPrgn = tcp->tccps[compno].roishift; /* 1 byte; SPrgn */ + if(SPrgn == 0) + continue; /* Yet another kludge */ + + fprintf(xmlout, "%s\n", s); /* Optional in main header, at most 1 per component */ + if(notes) + fprintf(xmlout, "%s\n", s); + /* Not retained or of interest: Lrgd */ + fprintf(xmlout, "%s 0\n", s); /* 1 byte */ + if(notes) + fprintf(xmlout, "%s \n", s); + fprintf(xmlout, "%s %d\n", s, compno); /* 1 or 2 bytes */ + fprintf(xmlout, "%s %d\n", s, SPrgn); /* 1 byte */ + if(notes) + fprintf(xmlout, "%s \n", s); + fprintf(xmlout, "POC != 1) + return; /* Not present */ + + fprintf(xmlout, "%s\n", s); /* Optional in main header, at most 1 per component */ + /* j2k_read_poc seems to allow accumulation of default pocs from multiple POC segments, but does + the spec really allow that? */ + /* 2 bytes, not retained; Lpoc */ + /* I probably didn't get this dump precisely right. */ + for (i = 0; i < tcp->numpocs; i++) { + poc = &tcp->pocs[i]; + fprintf(xmlout, "%s \n", s, i+1); + fprintf(xmlout, "%S %d\n", s, poc->resno0); /* 1 byte, RSpoc_i */ + if(notes) + fprintf(xmlout,"%s \n", s); + fprintf(xmlout, "%s %d\n", s, poc->compno0);/* j2k_img->numcomps <= 256 ? 1 byte : 2 bytes; CSpoc_i */ + if(notes) + fprintf(xmlout,"%s \n", s); + fprintf(xmlout, "%s %d\n", s, poc->layno1); /* int_min(cio_read(2), tcp->numlayers); /* 2 bytes; LYEpoc_i */ + if(notes) + fprintf(xmlout,"%s \n", s); + fprintf(xmlout, "%s %d\n", s, poc->resno1); /*int_min(cio_read(1), tccp->numresolutions); /* REpoc_i */ + if(notes) + fprintf(xmlout,"%s \n", s); + fprintf(xmlout, "%s %d\n", s, poc->compno1); /* int_min(cio_read(j2k_img->numcomps <= 256 ? 1 : 2), j2k_img->numcomps); /* CEpoc_i */ + if(notes) + fprintf(xmlout,"%s \n", s); + fprintf(xmlout, "%s %d\n", s, poc->prg); /* 1 byte Ppoc_i */ + if(notes) { + fprintf(xmlout,"%s \n", s); + fprintf(xmlout,"%s \n", s); + fprintf(xmlout,"%s \n", s); + } + fprintf(xmlout, "%s \n", s); + } + fprintf(xmlout, "%sppm != 1) + return; /* Not present */ +/* Main header uses indent of 10 spaces */ + fprintf(xmlout, " \n"); /* Optional in main header, but if not, must be in PPT or codestream */ + /* 2 bytes Lppm not saved */ + if(notes) { + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + } + + /* 1 byte, not retained ; Zppm is sequence # of this PPM header */ + /* 4 bytes, possibly overwritten multiple times in j2k_cp->ppm_previous: Nppm */ + /* Use j symbol for index instead of i, to make comparable with j2k_read_ppm */ + /* Not real clear whether to use ppm->store or ppm_len as upper bound */ + fprintf(xmlout, " \n"); + xml_out_dump_hex(xmlout, cp->ppm_data, cp->ppm_len); + /* Dump packet headers 1 byte at a time: lppm[i][j] */ + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); /* Optional in main header, but if not, must be in PPT or codestream */ +} + +/* ------------- */ + +void xml_out_frame_ppt(FILE *xmlout, j2k_tcp_t *tcp) { /* For tile-part header, not main (which uses PPM instead). */ +/* Either the PPM or PPT is required if the packet headers are not distributed in the bit stream */ +/* Use of PPM and PPT are mutually exclusive. */ +/* Compare j2k_read_ppt() */ + int j; + + if(tcp->ppt != 1) + return; /* Not present */ + + /* Tile-part indents are 12 spaces */ + fprintf(xmlout, " \n"); /* Optional in main header, but if not, must be in PPT or codestream */ + /* 2 bytes Lppm not saved */ + if(notes) { + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + } + + /* 1 byte, not retained ; Zppt is sequence # of this PPT header */ + /* 4 bytes, possibly overwritten multiple times in j2k_cp->ppt_previous: Nppt */ + /* Use j symbol for index instead of i, to make comparable with j2k_read_ppt */ + /* Not real clear whether to use ppt->store or ppt_len as upper bound */ + fprintf(xmlout, " \n"); + xml_out_dump_hex(xmlout, tcp->ppt_data, tcp->ppt_len); + /* Dump packet headers 1 byte at a time: lppt[i][j] */ + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); /* Optional in tile-part header, but if not, must be in PPM or codestream */ +} +#endif SUPPRESS_FOR_NOW + +/* ------------- */ + +void xml_out_frame_tlm(FILE* xmlout) { /* opt, main header only. May be multiple. */ +/* Compare j2k_read_tlm()... which doesn't retain anything! */ +/* Plan: Since this is only called from main header, not tilepart, use global j2k_default_tcp rather than parameter */ +/* Main header indents are 10 spaces */ +} + +/* ------------- */ + +void xml_out_frame_plm(FILE* xmlout) { /* opt, main header only; can be used in conjunction with tile-part's PLT */ +/* NO-OP. PLM NOT SAVED IN DATA STRUCTURE */ + /* Compare j2k_read_plm()... which doesn't retain anything! */ +/* Plan: Since this is only called from main header, not tilepart, use global j2k_default_tcp rather than parameter */ +/* Main header indents are 10 spaces */ +} + +/* ------------- */ + +void xml_out_frame_plt(FILE* xmlout, j2k_tcp_t *tcp) { /* opt, tile-part headers only; can be used in conjunction with main header's PLM */ +/* NO-OP. PLT NOT SAVED IN DATA STRUCTURE */ + /* Compare j2k_read_plt()... which doesn't retain anything! */ +/* Tile-part header indents are 12 spaces */ +} + +/* ------------- */ + +void xml_out_frame_crg(FILE* xmlout) { /* NO-OP. CRG NOT SAVED IN DATA STRUCTURE */ /* opt, main header only; */ +/* Compare j2k_read_crg()... which doesn't retain anything! */ +/* Plan: Since this is only called from main header, not tilepart, use global j2k_default_tcp rather than parameter */ +#ifdef NOTYET + THIS PSEUDOCODE IMAGINES THESE EXIST: j2k_default_tcp->crg, j2k_default_tcp->crg_i, j2k_default_tcp->crg_xcrg*, j2k_default_tcp->crg_ycrg* + (POSSIBLY DON'T NEED crg_i, CAN GET NUMBER OR COMPONENTS FROM ELSEWHERE) + if(j2k_default_tcp->crg != 1 || j2k_default_tcp->crg_i == 0) + return; /* Not present */ + +/* Main header indents are 10 spaces */ + fprintf(xmlout, " \n", j2k_default_tcp->crg_i); + if(notes) { + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + } + /* This isn't the most compact form of table, but is OK when number of components is small, as is likely. */ + for (i = 0; i < j2k_default_tcp->crg_i; i++) { + fprintf(xmlout, " \n", i+1); + fprintf(xmlout, " \n"); + if(raw) + fprintf(xmlout," %d\n", j2k_default_tcp->crg_xcrg[i]); + if(derived) { + /* Calculate n * 100%/65536; 4 digits after decimal point is sufficiently accurate */ + fprintf(xmlout," %.4f\n", ((double)j2k_default_tcp->crg_xcrg[i])/655.36); + /* We could do another calculation that include XRsiz[i]; maybe later. */ + } + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + if(raw) + fprintf(xmlout," %d\n", j2k_default_tcp->crg_ycrg[i]); + if(derived) { + fprintf(xmlout," %f\n", ((double)j2k_default_tcp->crg_ycrg[i])/655.36); + } + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + } + + fprintf(xmlout, " \n"); + +#endif +} + +/* ------------- */ + +/* Regrettably from a metadata point of view, j2k_read_com() skips over any comments in main header or tile-part-header */ +void xml_out_frame_com(FILE* xmlout, j2k_tcp_t *tcp) { /* NO-OP. COM NOT SAVED IN DATA STRUCTURE */ /* opt in main or tile-part headers; */ +/* Compare j2k_read_com()... which doesn't retain anything! */ +#ifdef NOTYET + char spaces[13] = " "; /* 12 spaces if tilepart*/ + char* s = spaces; + if(tcp == &j2k_default_tcp) { + s++;s++; /* shorten s to 10 spaces if main */ + } + THIS PSEUDOCODE IMAGINES THESE EXIST: tcp->com, tcp->com_len, tcp->com_data array + if(tcp->com != 1) + return; /* Not present */ + + fprintf(xmlout, "%s\n", s); /* Optional in main or tile-part header */ + xml_out_dump_hex_and_ascii(tcp->com_data, tcp->com_len, s); + fprintf(xmlout, "%s\n", s); +#endif +} + +void xml_out_dump_hex(FILE* xmlout, char *data, int data_len, char* s) { + /* s is a string of spaces for indent */ + int i; + + /* This is called when raw is true, or there is no appropriate derived form */ + fprintf(xmlout, "%s\n", s); + fprintf(xmlout, "%s ", s); /* Inadequate for pretty printing */ + for (i = 0; i < data_len; i++) { /* Dump packet headers */ + fprintf(xmlout, "%02x", data[i]); + } + fprintf(xmlout, "%s\n", s); +} + +/* Define this as an even number: */ +#define BYTES_PER_DUMP_LINE 40 +/* Current total width for Hex and ASCII is : 11 spaces lead + (3 * BPDL) + 2 spaces + BPDL */ +void xml_out_dump_hex_and_ascii(FILE* xmlout, char *data, int data_len, char* s) { + /* s is a string of spaces for indent */ + int i,j; + + if(raw) + xml_out_dump_hex(xmlout, data, data_len, s); + + if(derived) { + fprintf(xmlout, "%s\n", s); + for (i = 0; i < data_len; ) { + fprintf(xmlout,"%s ", s); /* Additional leading space added in loop */ + /* First column: hex */ + for (j = 0; j < BYTES_PER_DUMP_LINE; j++) /* Dump bytes */ + fprintf(xmlout," %02x", data[i+j]); + /* Space between columns... */ fprintf(xmlout, " "); + /* Second column: ASCII */ + for (j = 0; j < BYTES_PER_DUMP_LINE; j++, i++) { + if(isprint((int)data[i]) && i < data_len) + fprintf(xmlout,"%c", data[i]); + else + fprintf(xmlout," "); + } + /* If we also wanted to output UCS-2 Unicode as a third column, then entire document + must use fwprintf. Forget about it for now. As it stands, if data is UCS-2 format but still + the ASCII set, then we'll be able to read every other byte as ASCII in column 2. If + data is UTF-8 format but still ASCII, then we'll be able to read every byte as ASCII + in column 2. */ + } + fprintf(xmlout, "%s\n", s); + } +} + + +/* ------------- */ + +void xml_out_frame_jp2h(FILE* xmlout, jp2_struct_t *jp2_struct) { /* JP2 Header */ +/* Compare jp2_read_jp2h(jp2_struct_t * jp2_struct) */ + int i; + + fprintf(xmlout, " \n"); + +/* Compare jp2_read_ihdr(jp2_struct)) */ + fprintf(xmlout, " \n"); + fprintf(xmlout, " %d\n", jp2_struct->h); /* 4 bytes */ + fprintf(xmlout, " %d\n", jp2_struct->w); /* 4 bytes */ + if(notes) + fprintf(xmlout, " \n"); + fprintf(xmlout, " %d\n", jp2_struct->numcomps); /* 2 bytes */ + if(notes) + fprintf(xmlout, " \n"); /* 2 bytes */ + fprintf(xmlout, " \n"); /* 1 byte */ + if(jp2_struct->bpc == 255) { + fprintf(xmlout, " 0x%02x\n", jp2_struct->bpc); /* 1 byte */ + if(notes) + fprintf(xmlout, " \n"); + } else { /* Not 0xff */ + if(raw) { + fprintf(xmlout, " 0x%02x\n", jp2_struct->bpc); /* 1 byte */ + if(notes) + fprintf(xmlout," \n"); + } + if(derived) { + fprintf(xmlout, " %d\n", jp2_struct->bpc & 0x7f); + fprintf(xmlout, " %d\n", jp2_struct->bpc >> 7); + } + } + fprintf(xmlout, " \n"); + fprintf(xmlout, " %d\n", jp2_struct->C); /* 1 byte */ + if(notes) + fprintf(xmlout, " \n"); /* 2 bytes */ + fprintf(xmlout, " %d\n", jp2_struct->UnkC); /* 1 byte */ + if(notes) + fprintf(xmlout, " \n"); /* 1 byte */ + fprintf(xmlout, " %d\n", jp2_struct->IPR); /* 1 byte */ + if(notes) + fprintf(xmlout, " \n"); /* 2 bytes */ + fprintf(xmlout, " \n"); + + if (jp2_struct->bpc == 255) + { + fprintf(xmlout, " \n"); + if(notes) + fprintf(xmlout, " \n"); + /* Bits per pixel varies with components */ + /* Compare jp2_read_bpcc(jp2_struct) */ + for (i = 0; i < (int)jp2_struct->numcomps; i++) { + if(raw) + fprintf(xmlout," 0x%02x\n", jp2_struct->comps[i].bpcc); /* 1 byte */ + if(derived) { + fprintf(xmlout," %d\n", (jp2_struct->comps[i].bpcc & 0x7f)+1); + fprintf(xmlout," %d\n", jp2_struct->comps[i].bpcc >> 7); + } + } + fprintf(xmlout, " \n"); + } + + /* Compare jp2_read_colr(jp2_struct) */ + fprintf(xmlout, " \n"); + fprintf(xmlout, " %d\n", jp2_struct->meth); /* 1 byte */ + if(notes) { + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + } + fprintf(xmlout, " %d\n", jp2_struct->precedence); /* 1 byte */ + if(notes) + fprintf(xmlout, " \n"); + fprintf(xmlout, " %d\n", jp2_struct->approx); /* 1 byte */ + if(notes) + fprintf(xmlout, " \n"); + + if (jp2_struct->meth == 1) { + fprintf(xmlout, " %d\n", jp2_struct->enumcs); /* 4 bytes */ + if(notes) { + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + } + } + else + if(notes) + fprintf(xmlout, " \n"); + /* only 1 byte is read and nothing stored */ + fprintf(xmlout, " \n"); + + /* TO DO? No OpenJPEG support. + Palette 'pclr' + ComponentMapping 'cmap' + ChannelDefinition 'cdef' + Resolution 'res' + */ + fprintf(xmlout, " \n"); +} +/* ------------- */ + +#ifdef NOTYET +IMAGE these use cp structure, extended... but we could use a new data structure instead +void xml_out_frame_jp2i(FILE* xmlout, j2k_cp_t *cp) { + /* IntellectualProperty 'jp2i' (no restrictions on location) */ + int i; + IMAGE cp->jp2i, cp->jp2i_count, cp->jp2i_data (array of chars), cp->cp2i_len (array of ints) + if(cp->jp2i != 1) + return; /* Not present */ + + for(i = 0; i < cp->jp2i_count; i++) + { + fprintf(xmlout, " \n"); + /* I think this can be anything, including binary, so do a dump */ + /* Is it better to indent or not indent this content? Indent is better for reading, but + worse for cut/paste. */ + xml_out_dump_hex_and_ascii(xmlout, cp->jp2i_data[i], cp->jp2i_len[i]); + fprintf(xmlout, " \n"); + } +} + +void xml_out_frame_xml(FILE* xmlout, j2k_cp_t *cp) { + /* XML 'xml\040' (0x786d6c20). Can appear multiply, before or after jp2c codestreams */ + IMAGE cp->xml, cp->xml_count, cp->xml_data (array of chars) + MAYBE WE DON'T NEED cp->xml_len (array of ints) IF WE ASSUME xml_data IS NULL-TERMINATED. + ASSUME ASSUME EACH LINE IS ENDED BY \n. + int i; + if(cp->xml != 1) + return; /* Not present */ + + for(i = 0; i < cp->xml_count; i++) + { + fprintf(xmlout, " \n", i+1); + /* Is it better to indent or not indent this content? Indent is better for reading, but + worse for cut/paste. Being lazy, didn't indent here. */ + fprintf(xmlout,cp->xml_data[i]); /* May be multiple lines */ /* Could check if this is well-formed */ + fprintf(xmlout, " \n"); + } +} + +void xml_out_frame_uuid(FILE* xmlout, j2k_cp_t *cp) { + /* UUID 'uuid' (top level only) */ + /* Part I 1.7.2 says: may appear multiply in JP2 file, anywhere except before File Type box */ + /* Part III 5.2.1 says: Private extensions shall be achieved through the 'uuid' type. */ + /* A UUID is a 16-byte value. There is a conventional string representation for it: + "0x12345678-9ABC-DEF0-1234-567890ABCDEF". Let's assume that is what is stored in uuid_value */ + + /* Part III 6.1 Any other MJ2 box type could be alternatively written as a 'uuid' box, with value given + as : 0xXXXXXXXX-0011-0010-8000-00AA00389B71, where the Xs are the boxtype in hex. However, + such a file is "not compliant; systems may choose to read [such] objects ... as equivalent to the box of + the same type, or not." Here, we choose not to. */ + int i; + IMAGE cp->uuid, cp->uuid_count, cp->uuid_value (array of uuids... let's say fixed-length strings) cp->uuid_data (array of char buffers), cp->uuid_len (array of ints) + if(cp->juuid != 1) + return; /* Not present */ + + for(i = 0; i < cp->uuid_count; i++) + { + fprintf(xmlout, " + fprintf(xmlout, " %s\n", cp->uuid_value[i]); + fprintf(xmlout, " \n"); + /* I think this can be anything, including binary, so do a dump */ + /* Is it better to indent or not indent this content? Indent is better for reading, but + worse for cut/paste. */ + xml_out_dump_hex_and_ascii(xmlout, cp->uuid_data[i], cp->uuid_len[i]); + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + } +} + +void xml_out_frame_uinf(FILE* xmlout, j2k_cp_t *cp) { + /* UUIDInfo 'uinf', includes UUIDList 'ulst' and URL 'url\40' */ + /* Part I 1.7.3 says: may appear multiply in JP2 file, anywhere at the top level except before File Type box */ + /* So there may be multiple ulst's, and each can have multiple UUIDs listed (with a single URL) */ + /* This is not quite as vendor-specific as UUIDs, or at least is meant to be generally readable */ + /* Assume UUIDs stored in canonical string format */ + int i, j; + IMAGE cp->uinf, cp->uinf_count, cp->uinf_ulst_nu (array of ints) + cp->uinf_uuid (2 dimensional array of uuids... let's say fixed-length strings), + cp->uinf_url (array of char buffers) + + if(cp->uinf != 1) + return; /* Not present */ + + for(i = 0; i < cp->uuid_count; i++) + { + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n",cp->cp->uinf_ulst_nu[i]); + for(j = 0; j < cp->uinf_ulst_nu[i]; j++) + fprintf(xmlout, " %s\n", cp->uuif_uuid[i][j], j+1); + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + /* Could add VERS and FLAG here */ + fprintf(xmlout, " \n"); + fprintf(xmlout, " %s",cp->uinf_url[i]); /* Probably single line, so indent works */ /* In theory, could check if this is well-formed, or good live link */ + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + fprintf(xmlout, " \n"); + } +} + +IMAGE these use cp structure, extended... but we could use a new data structure instead +void xml_out_frame_unknown_type(FILE* xmlout, j2k_cp_t *cp) { + /* Part III 5.2.1 says "Type fields not defined here are reserved. Private extensions + shall be acieved through the 'uuid' type." [This implies an unknown + type would be an error, but then...] "Boxes not explicitly defined in this standard, + or otherwise unrecognized by a reader, may be ignored." + Also, it says "the following types are not and will not be used, or used only in + their existing sense, in future versions of this specification, to avoid conflict + with existing content using earlier pre-standard versions of this format: + clip, crgn, matt, kmat, pnot, ctab, load, imap; + track reference types tmcd, chap, sync,scpt, ssrc" + [But good luck figuring out the mapping.] + Part III Amend. 2 4.1 is stronger: "All these specifications [of this family, e.g., + JP2 Part I, ISO Base format (Part 12) leading to MP4, Quicktime, and possibly including + MJ2] require that readers ignore objects that are unrecognizable to them". + */ + int i; + IMAGE cp->unknown_type, cp->unknown_type_count, cp->unknown_type_boxtype (array of buf[5]s), cp->unknown_type_data (array of chars), cp->unknown_type_len (array of ints) + if(cp->unknown_type != 1) + return; /* Not present */ + + for(i = 0; i < cp->unknown_type_count; i++) + { + fprintf(xmlout, " \n", cp->unknown_type_boxtype[i]); + /* Can be anything, including binary, so do a dump */ + /* Is it better to indent or not indent this content? Indent is better for reading, but + worse for cut/paste. */ + xml_out_dump_hex_and_ascii(xmlout, cp->unknown_type_data[i], cp->unknown_type_len[i]); + fprintf(xmlout, " \n"); + } +} + +#endif \ No newline at end of file diff --git a/mj2/MJ2_codec/meta_out.h b/mj2/MJ2_codec/meta_out.h new file mode 100644 index 00000000..bfe9d190 --- /dev/null +++ b/mj2/MJ2_codec/meta_out.h @@ -0,0 +1,13 @@ +/* meta_out.h */ +/* Dump MJ2, JP2 metadata (partial so far) to xml file */ +/* Callable from mj2_to_metadata */ +/* Contributed to Open JPEG by Glenn Pearson, U.S. National Library of Medicine */ + +#define BOOL int +#define FALSE 0 +#define TRUE 1 + +void xml_write_init(BOOL n, BOOL t, BOOL r, BOOL d); + +int xml_write_struct(FILE *file, FILE *xmlout, mj2_movie_t * movie, unsigned int sampleframe, char* stringDTD); + diff --git a/mj2/MJ2_codec/mj2.c b/mj2/MJ2_codec/mj2.c new file mode 100644 index 00000000..cdafe751 --- /dev/null +++ b/mj2/MJ2_codec/mj2.c @@ -0,0 +1,2798 @@ +/* +* Copyright (c) 2003-2004, François-Olivier Devaux +* Copyright (c) 2003-2004, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions +* are met: +* 1. Redistributions of source code must retain the above copyright +* notice, this list of conditions and the following disclaimer. +* 2. Redistributions in binary form must reproduce the above copyright +* notice, this list of conditions and the following disclaimer in the +* documentation and/or other materials provided with the distribution. +* +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS' +* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE +* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +* POSSIBILITY OF SUCH DAMAGE. +*/ + +#include +#include +#include +#include +#include + +#include "mj2.h" +#include + +#define MJ2_JP 0x6a502020 +#define MJ2_FTYP 0x66747970 +#define MJ2_MJ2 0x6d6a7032 +#define MJ2_MJ2S 0x6d6a3273 +#define MJ2_MDAT 0x6d646174 +#define MJ2_MOOV 0x6d6f6f76 +#define MJ2_MVHD 0x6d766864 +#define MJ2_TRAK 0x7472616b +#define MJ2_TKHD 0x746b6864 +#define MJ2_MDIA 0x6d646961 +#define MJ2_MDHD 0x6d646864 +#define MJ2_MHDR 0x6d686472 +#define MJ2_HDLR 0x68646C72 +#define MJ2_MINF 0x6d696e66 +#define MJ2_VMHD 0x766d6864 +#define MJ2_SMHD 0x736d6864 +#define MJ2_HMHD 0x686d6864 +#define MJ2_DINF 0x64696e66 +#define MJ2_DREF 0x64726566 +#define MJ2_URL 0x75726c20 +#define MJ2_URN 0x75726e20 +#define MJ2_STBL 0x7374626c +#define MJ2_STSD 0x73747364 +#define MJ2_STTS 0x73747473 +#define MJ2_STSC 0x73747363 +#define MJ2_STSZ 0x7374737A +#define MJ2_STCO 0x7374636f +#define MJ2_MOOF 0x6d6f6f66 +#define MJ2_FREE 0x66726565 +#define MJ2_SKIP 0x736b6970 +#define MJ2_JP2C 0x6a703263 +#define MJ2_FIEL 0x6669656c +#define MJ2_JP2P 0x6a703270 +#define MJ2_JP2X 0x6a703278 +#define MJ2_JSUB 0x6a737562 +#define MJ2_ORFO 0x6f72666f +#define MJ2_MVEX 0x6d766578 +#define MJ2_JP2 0x6a703220 +#define MJ2_J2P0 0x4a325030 + +/* +* +* Free movie structure memory +* +*/ +void mj2_memory_free(mj2_movie_t * movie) +{ + int i; + mj2_tk_t *tk=NULL; + + if (movie->num_cl != 0) + free(movie->cl); + + for (i = 0; i < movie->num_vtk + movie->num_stk + movie->num_htk; i++) { + tk = &movie->tk[i]; + if (tk->name_size != 0) + free(tk->name); + if (tk->track_type == 0) {// Video track + if (tk->jp2_struct.comps != 0) + free(tk->jp2_struct.comps); + if (tk->jp2_struct.cl != 0) + free(tk->jp2_struct.cl); + if (tk->num_jp2x != 0) + free(tk->jp2xdata); + + } + if (tk->num_url != 0) + free(tk->url); + if (tk->num_urn != 0) + free(tk->urn); + if (tk->num_br != 0) + free(tk->br); + if (tk->num_tts != 0) + free(tk->tts); + if (tk->num_chunks != 0) + free(tk->chunk); + if (tk->num_samplestochunk != 0) + free(tk->sampletochunk); + if (tk->num_samples != 0) + free(tk->sample); + } + + free(movie->tk); +} + +/* +* +* Read box headers +* +*/ + +int mj2_read_boxhdr(mj2_box_t * box) +{ + box->init_pos = cio_tell(); + box->length = cio_read(4); + box->type = cio_read(4); + if (box->length == 1) { + if (cio_read(4) != 0) { + fprintf(stderr, "Error: Cannot handle box sizes higher than 2^32\n"); + return 1; + }; + box->length = cio_read(4); + if (box->length == 0) + box->length = cio_numbytesleft() + 12; + } + else if (box->length == 0) { + box->length = cio_numbytesleft() + 8; + } + return 0; +} + +/* +* +* Initialisation of a Standard Movie, given a simple movie structure defined by the user +* The movie will have one sample per chunk +* +* Arguments: mj2_movie_t * movie +* Several variables of "movie" must be defined in order to enable a correct execution of +* this function: +* - The number of tracks of each type (movie->num_vtk, movie->num_stk, movie->num_htk) +* - The memory for each must be allocated (movie->tk) +* - For each track: +* The track type (tk->track_type) +* The number of sample (tk->num_samples) +* The sample rate (tk->sample_rate) +* +*/ + +int mj2_init_stdmovie(mj2_movie_t * movie) +{ + int i; + unsigned int j; + time_t ltime; + + movie->brand = MJ2_MJ2; + movie->minversion = 0; + movie->num_cl = 2; + movie->cl = + (unsigned int *) malloc(movie->num_cl * sizeof(unsigned int)); + + movie->cl[0] = MJ2_MJ2; + movie->cl[1] = MJ2_MJ2S; + time(<ime); /* Time since 1/1/70 */ + movie->creation_time = (unsigned int) ltime + 2082844800; /* Seconds between 1/1/04 and 1/1/70 */ + movie->timescale = 1000; + + movie->rate = 1 << 16; /* Rate to play presentation (default = 0x00010000) */ + movie->volume = 1 << 8; /* Movie volume (default = 0x0100) */ + movie->trans_matrix[0] = 0x00010000; /* Transformation matrix for video */ + movie->trans_matrix[1] = 0; /* Unity is { 0x00010000,0,0,0,0x00010000,0,0,0,0x40000000 } */ + movie->trans_matrix[2] = 0; + movie->trans_matrix[3] = 0; + movie->trans_matrix[4] = 0x00010000; + movie->trans_matrix[5] = 0; + movie->trans_matrix[6] = 0; + movie->trans_matrix[7] = 0; + movie->trans_matrix[8] = 0x40000000; + movie->next_tk_id = 1; + + for (i = 0; i < movie->num_htk + movie->num_stk + movie->num_vtk; i++) { + mj2_tk_t *tk = &movie->tk[i]; + movie->next_tk_id++; + tk->jp2_struct.comps = NULL; + tk->jp2_struct.cl = NULL; + + if (tk->track_type == 0) { + if (tk->num_samples == 0) + return 1; + + tk->Dim[0] = 0; + tk->Dim[1] = 0; + + tk->timescale = 1000; /* Timescale = 1 ms */ + + tk->chunk[0].num_samples = 1; + tk->chunk[0].sample_descr_idx = 1; + + tk->same_sample_size = 0; + + tk->num_samplestochunk = 1; /* One sample per chunk */ + tk->sampletochunk = + (mj2_sampletochunk_t *) malloc(tk->num_samplestochunk * + sizeof(mj2_sampletochunk_t)); + tk->sampletochunk[0].first_chunk = 1; + tk->sampletochunk[0].samples_per_chunk = 1; + tk->sampletochunk[0].sample_descr_idx = 1; + + if (tk->sample_rate == 0) { + fprintf(stderr,"Error while initializing MJ2 movie: Sample rate of track %d must be different from zero\n",tk->track_ID); + return 1; + } + + for (j = 0; j < tk->num_samples; j++) { + tk->sample[j].sample_delta = tk->timescale / tk->sample_rate; + } + + tk->num_tts = 1; + tk->tts = (mj2_tts_t *) malloc(tk->num_tts * sizeof(mj2_tts_t)); + tk->tts[0].sample_count = tk->num_samples; + tk->tts[0].sample_delta = tk->timescale / tk->sample_rate; + + tk->horizresolution = 0x00480000; /* Horizontal resolution (typically 72) */ + tk->vertresolution = 0x00480000; /* Vertical resolution (typically 72) */ + tk->compressorname[0] = 0x0f4d6f74; /* Compressor Name[]: Motion JPEG2000 */ + tk->compressorname[1] = 0x696f6e20; + tk->compressorname[2] = 0x4a504547; + tk->compressorname[3] = 0x32303030; + tk->compressorname[4] = 0x00120000; + tk->compressorname[5] = 0; + tk->compressorname[6] = 0x00000042; + tk->compressorname[7] = 0x000000DC; + tk->num_url = 0; /* Number of URL */ + tk->num_urn = 0; /* Number of URN */ + tk->graphicsmode = 0; /* Graphicsmode */ + tk->opcolor[0] = 0; /* OpColor */ + tk->opcolor[1] = 0; /* OpColor */ + tk->opcolor[2] = 0; /* OpColor */ + tk->creation_time = movie->creation_time; /* Seconds between 1/1/04 and 1/1/70 */ + tk->language = 0; /* Language (undefined) */ + tk->layer = 0; + tk->volume = 1 << 8; /* Movie volume (default = 0x0100) */ + tk->trans_matrix[0] = 0x00010000; /* Transformation matrix for track */ + tk->trans_matrix[1] = 0; /* Unity is { 0x00010000,0,0,0,0x00010000,0,0,0,0x40000000 } */ + tk->trans_matrix[2] = 0; + tk->trans_matrix[3] = 0; + tk->trans_matrix[4] = 0x00010000; + tk->trans_matrix[5] = 0; + tk->trans_matrix[6] = 0; + tk->trans_matrix[7] = 0; + tk->trans_matrix[8] = 0x40000000; + tk->fieldcount = 1; + tk->fieldorder = 0; + tk->or_fieldcount = 1; + tk->or_fieldorder = 0; + tk->num_br = 2; + tk->br = (unsigned int *) malloc(tk->num_br * sizeof(unsigned int)); + tk->br[0] = MJ2_JP2; + tk->br[1] = MJ2_J2P0; + tk->num_jp2x = 0; + tk->hsub = 2; /* 4:2:0 */ + tk->vsub = 2; /* 4:2:0 */ + tk->hoff = 0; + tk->voff = 0; + tk->visual_w = tk->w << 16; + tk->visual_h = tk->h << 16; + } + else { + tk->num_br = 0; + tk->jp2xdata = NULL; + } + } + return 0; +} + +/* +* Time To Sample box Decompact +* +*/ +void mj2_tts_decompact(mj2_tk_t * tk) +{ + int i, j; + tk->num_samples = 0; + for (i = 0; i < tk->num_tts; i++) { + tk->num_samples += tk->tts[i].sample_count; + } + + tk->sample = + (mj2_sample_t *) malloc(tk->num_samples * sizeof(mj2_sample_t)); + + for (i = 0; i < tk->num_tts; i++) { + for (j = 0; j < tk->tts[i].sample_count; j++) { + tk->sample[j].sample_delta = tk->tts[i].sample_delta; + } + } +} + +/* +* Sample To Chunk box Decompact +* +*/ +void mj2_stsc_decompact(mj2_tk_t * tk) +{ + int j, i; + unsigned int k; + int sampleno=0; + + if (tk->num_samplestochunk == 1) { + tk->num_chunks = + (unsigned int) ceil((double) tk->num_samples / + (double) tk->sampletochunk[0].samples_per_chunk); + tk->chunk = + (mj2_chunk_t *) malloc(tk->num_chunks * sizeof(mj2_chunk_t)); + for (k = 0; k < tk->num_chunks; k++) { + tk->chunk[k].num_samples = tk->sampletochunk[0].samples_per_chunk; + } + + } else { + tk->chunk = + (mj2_chunk_t *) malloc(tk->num_samples * sizeof(mj2_chunk_t)); + tk->num_chunks = 0; + for (i = 0; i < tk->num_samplestochunk -1 ; i++) { + for (j = tk->sampletochunk[i].first_chunk - 1; + j < tk->sampletochunk[i + 1].first_chunk - 1; j++) { + tk->chunk[j].num_samples = tk->sampletochunk[i].samples_per_chunk; + tk->num_chunks++; + sampleno += tk->chunk[j].num_samples; + } + } + tk->num_chunks += (int)(tk->num_samples - sampleno) / tk->sampletochunk[tk->num_samplestochunk - 1].samples_per_chunk; + for (k = tk->sampletochunk[tk->num_samplestochunk - 1].first_chunk - 1; + k < tk->num_chunks; k++) { + tk->chunk[k].num_samples = + tk->sampletochunk[tk->num_samplestochunk - 1].samples_per_chunk; + } + tk->chunk = realloc(tk->chunk, tk->num_chunks * sizeof(mj2_chunk_t)); + } + +} + + +/* +* Chunk offset box Decompact +* +*/ +void mj2_stco_decompact(mj2_tk_t * tk) +{ + int j; + unsigned int i; + int k = 0; + int intra_chunk_offset; + + for (i = 0; i < tk->num_chunks; i++) { + intra_chunk_offset = 0; + for (j = 0; j < tk->chunk[i].num_samples; j++) { + tk->sample[k].offset = intra_chunk_offset + tk->chunk[i].offset; + intra_chunk_offset += tk->sample[k].sample_size; + k++; + } + } +} + +/* +* Write the JP box +* +* JP Signature box +* +*/ +void mj2_write_jp() +{ + mj2_box_t box; + box.init_pos = cio_tell(); + cio_skip(4); + + cio_write(MJ2_JP, 4); /* JP */ + cio_write(0x0d0a870a, 4); /* 0x0d0a870a required in a JP box */ + + box.length = cio_tell() - box.init_pos; + cio_seek(box.init_pos); + cio_write(box.length, 4); + cio_seek(box.init_pos + box.length); +} + +/* +* Read the JP box +* +* JPEG 2000 signature +* +*/ +int mj2_read_jp() +{ + mj2_box_t box; + + mj2_read_boxhdr(&box); + if (MJ2_JP != box.type) { /* Check Marker */ + fprintf(stderr, "Error: Expected JP Marker\n"); + return 1; + } + if (0x0d0a870a != cio_read(4)) { /* read the 0x0d0a870a required in a JP box */ + fprintf(stderr, "Error with JP Marker\n"); + return 1; + } + if (cio_tell() - box.init_pos != box.length) { /* Check box length */ + fprintf(stderr, "Error with JP Box size \n"); + return 1; + } + return 0; + +} + +/* +* Write the FTYP box +* +* File type box +* +*/ +void mj2_write_ftyp(mj2_movie_t * movie) +{ + int i; + mj2_box_t box; + box.init_pos = cio_tell(); + cio_skip(4); + + cio_write(MJ2_FTYP, 4); /* FTYP */ + cio_write(movie->brand, 4); /* BR */ + cio_write(movie->minversion, 4); /* MinV */ + + for (i = 0; i < movie->num_cl; i++) + cio_write(movie->cl[i], 4); /* CL */ + + box.length = cio_tell() - box.init_pos; + cio_seek(box.init_pos); + cio_write(box.length, 4); /* Length */ + cio_seek(box.init_pos + box.length); +} + +/* +* Read the FTYP box +* +* File type box +* +*/ +int mj2_read_ftyp(mj2_movie_t * movie) +{ + int i; + mj2_box_t box; + + mj2_read_boxhdr(&box); /* Box Size */ + if (MJ2_FTYP != box.type) { + fprintf(stderr, "Error: Expected FTYP Marker\n"); + return 1; + } + + movie->brand = cio_read(4); /* BR */ + movie->minversion = cio_read(4); /* MinV */ + movie->num_cl = (box.length - 16) / 4; + movie->cl = + (unsigned int *) malloc(movie->num_cl * sizeof(unsigned int)); + + for (i = movie->num_cl - 1; i > -1; i--) + movie->cl[i] = cio_read(4); /* CLi */ + + if (cio_tell() - box.init_pos != box.length) { + fprintf(stderr, "Error with FTYP Box\n"); + return 1; + } + return 0; +} + + +/* +* Write the STCO box +* +* Chunk Offset Box +* +*/ +void mj2_write_stco(mj2_tk_t * tk) +{ + mj2_box_t box; + unsigned int i; + + box.init_pos = cio_tell(); + cio_skip(4); + cio_write(MJ2_STCO, 4); /* STCO */ + + cio_write(0, 4); /* Version = 0, flags = 0 */ + + cio_write(tk->num_chunks, 4); /* Entry Count */ + + for (i = 0; i < tk->num_chunks; i++) { + cio_write(tk->chunk[i].offset, 4); /* Entry offset */ + } + + box.length = cio_tell() - box.init_pos; + cio_seek(box.init_pos); + cio_write(box.length, 4); /* L */ + cio_seek(box.init_pos + box.length); +} + +/* +* Read the STCO box +* +* Chunk Offset Box +* +*/ +int mj2_read_stco(mj2_tk_t * tk) +{ + unsigned int i; + mj2_box_t box; + + mj2_read_boxhdr(&box); /* Box Size */ + if (MJ2_STCO != box.type) { + fprintf(stderr, "Error: Expected STCO Marker\n"); + return 1; + } + + if (0 != cio_read(1)) { /* Version = 0 */ + fprintf(stderr, "Error: Only Version 0 handled in STCO box\n"); + return 1; + } + + if (0 != cio_read(3)) { /* Flags = 0 */ + fprintf(stderr, "Error with flag in STCO box. Expected flag 0\n"); + return 1; + } + + + if (cio_read(4) != tk->num_chunks) { + fprintf(stderr, + "Error in STCO box: expecting same amount of entry-count as chunks \n"); + } else { + for (i = 0; i < tk->num_chunks; i++) { + tk->chunk[i].offset = cio_read(4); /* Entry offset */ + } + } + + mj2_stco_decompact(tk); + + + if (cio_tell() - box.init_pos != box.length) { + fprintf(stderr, "Error with STCO Box size\n"); + return 1; + } + return 0; +} + +/* +* Write the STSZ box +* +* Sample size box +* +*/ +void mj2_write_stsz(mj2_tk_t * tk) +{ + mj2_box_t box; + unsigned int i; + + box.init_pos = cio_tell(); + cio_skip(4); + cio_write(MJ2_STSZ, 4); /* STSZ */ + + cio_write(0, 4); /* Version = 0, flags = 0 */ + + if (tk->same_sample_size == 1) { /* If they all have the same size */ + cio_write(tk->sample[0].sample_size, 4); /* Size */ + + cio_write(1, 4); /* Entry count = 1 */ + } + + else { + cio_write(0, 4); /* Sample Size = 0 becase they all have different sizes */ + + cio_write(tk->num_samples, 4); /* Sample Count */ + + for (i = 0; i < tk->num_samples; i++) { + cio_write(tk->sample[i].sample_size, 4); + } + } + + box.length = cio_tell() - box.init_pos; + cio_seek(box.init_pos); + cio_write(box.length, 4); /* L */ + cio_seek(box.init_pos + box.length); +} + +/* +* Read the STSZ box +* +* Sample size box +* +*/ +int mj2_read_stsz(mj2_tk_t * tk) +{ + int sample_size; + unsigned int i; + mj2_box_t box; + + mj2_read_boxhdr(&box); /* Box Size */ + if (MJ2_STSZ != box.type) { + fprintf(stderr, "Error: Expected STSZ Marker\n"); + return 1; + } + + + if (0 != cio_read(1)) { /* Version = 0 */ + fprintf(stderr, "Error: Only Version 0 handled in STSZ box\n"); + return 1; + } + + if (0 != cio_read(3)) { /* Flags = 0 */ + fprintf(stderr, "Error with flag in STSZ box. Expected flag 0\n"); + return 1; + } + + sample_size = cio_read(4); + + if (sample_size != 0) { /* Samples do have the same size */ + tk->same_sample_size = 1; + for (i = 0; i < tk->num_samples; i++) { + tk->sample[i].sample_size = sample_size; + } + cio_skip(4); /* Sample count = 1 */ + } else { + tk->same_sample_size = 0; + if (tk->num_samples != cio_read(4)) { /* Sample count */ + fprintf(stderr, + "Error in STSZ box. Expected that sample-count is number of samples in track\n"); + return 1; + } + for (i = 0; i < tk->num_samples; i++) { + tk->sample[i].sample_size = cio_read(4); /* Sample Size */ + } + + if (cio_tell() - box.init_pos != box.length) { + fprintf(stderr, "Error with STSZ Box size\n"); + return 1; + } + } + return 0; + +} + +/* +* Write the STSC box +* +* Sample to Chunk +* +*/ +void mj2_write_stsc(mj2_tk_t * tk) +{ + int i; + mj2_box_t box; + + box.init_pos = cio_tell(); + cio_skip(4); + cio_write(MJ2_STSC, 4); /* STSC */ + + cio_write(0, 4); /* Version = 0, flags = 0 */ + + cio_write(tk->num_samplestochunk, 4); /* Entry Count */ + + for (i = 0; i < tk->num_samplestochunk; i++) { + cio_write(tk->sampletochunk[i].first_chunk, 4); /* First Chunk */ + cio_write(tk->sampletochunk[i].samples_per_chunk, 4); /* Samples per chunk */ + cio_write(tk->sampletochunk[i].sample_descr_idx, 4); /* Samples description index */ + } + + + box.length = cio_tell() - box.init_pos; + cio_seek(box.init_pos); + cio_write(box.length, 4); /* L */ + cio_seek(box.init_pos + box.length); +} + +/* +* Read the STSC box +* +* Sample to Chunk +* +*/ +int mj2_read_stsc(mj2_tk_t * tk) +{ + int i; + mj2_box_t box; + + mj2_read_boxhdr(&box); /* Box Size */ + if (MJ2_STSC != box.type) { + fprintf(stderr, "Error: Expected STSC Marker\n"); + return 1; + } + + + if (0 != cio_read(1)) { /* Version = 0 */ + fprintf(stderr, "Error: Only Version 0 handled in STSC box\n"); + return 1; + } + + if (0 != cio_read(3)) { /* Flags = 0 */ + fprintf(stderr, "Error with flag in STSC box. Expected flag 0\n"); + return 1; + } + + tk->num_samplestochunk = cio_read(4); + + tk->sampletochunk = + (mj2_sampletochunk_t *) malloc(tk->num_samplestochunk * + sizeof(mj2_sampletochunk_t)); + + + for (i = 0; i < tk->num_samplestochunk; i++) { + tk->sampletochunk[i].first_chunk = cio_read(4); + tk->sampletochunk[i].samples_per_chunk = cio_read(4); + tk->sampletochunk[i].sample_descr_idx = cio_read(4); + } + + mj2_stsc_decompact(tk); /* decompact sample to chunk box */ + + + if (cio_tell() - box.init_pos != box.length) { + fprintf(stderr, "Error with STSC Box size\n"); + return 1; + } + return 0; +} + +/* +* Write the STTS box +* +* Time to Sample Box +* +*/ +void mj2_write_stts(mj2_tk_t * tk) +{ + + int i; + mj2_box_t box; + + box.init_pos = cio_tell(); + cio_skip(4); + cio_write(MJ2_STTS, 4); /* STTS */ + + cio_write(0, 4); /* Version = 0, flags = 0 */ + + cio_write(tk->num_tts, 4); /* entry_count */ + for (i = 0; i < tk->num_tts; i++) { + cio_write(tk->tts[i].sample_count, 4); /* Sample-count */ + cio_write(tk->tts[i].sample_delta, 4); /* Sample-Delta */ + } + + box.length = cio_tell() - box.init_pos; + cio_seek(box.init_pos); + cio_write(box.length, 4); /* L */ + cio_seek(box.init_pos + box.length); +} + +/* +* Read the STTS box +* +* +* +*/ +int mj2_read_stts(mj2_tk_t * tk) +{ + int i; + + mj2_box_t box; + + mj2_read_boxhdr(&box); + if (MJ2_STTS != box.type) { + fprintf(stderr, "Error: Expected STTS Marker\n"); + return 1; + } + + + if (0 != cio_read(1)) { /* Version = 0 */ + fprintf(stderr, "Error: Only Version 0 handled in STTS box\n"); + return 1; + } + + if (0 != cio_read(3)) { /* Flags = 0 */ + fprintf(stderr, "Error with flag in STTS box. Expected flag 0\n"); + return 1; + } + + tk->num_tts = cio_read(4); + + tk->tts = (mj2_tts_t *) malloc(tk->num_tts * sizeof(mj2_tts_t)); + + for (i = 0; i < tk->num_tts; i++) { + tk->tts[i].sample_count = cio_read(4); + tk->tts[i].sample_delta = cio_read(4); + } + + mj2_tts_decompact(tk); + + if (cio_tell() - box.init_pos != box.length) { + fprintf(stderr, "Error with STTS Box size\n"); + return 1; + } + return 0; +} + +/* +* Write the FIEL box +* +* Field coding Box +* +*/ +void mj2_write_fiel(mj2_tk_t * tk) +{ + + mj2_box_t box; + + box.init_pos = cio_tell(); + cio_skip(4); + cio_write(MJ2_FIEL, 4); /* STTS */ + + cio_write(tk->fieldcount, 1); /* Field count */ + cio_write(tk->fieldorder, 1); /* Field order */ + + + box.length = cio_tell() - box.init_pos; + cio_seek(box.init_pos); + cio_write(box.length, 4); /* L */ + cio_seek(box.init_pos + box.length); +} + +/* +* Read the FIEL box +* +* Field coding Box +* +*/ +int mj2_read_fiel(mj2_tk_t * tk) +{ + + mj2_box_t box; + + mj2_read_boxhdr(&box); + if (MJ2_FIEL != box.type) { + fprintf(stderr, "Error: Expected FIEL Marker\n"); + return 1; + } + + + tk->fieldcount = cio_read(1); + tk->fieldorder = cio_read(1); + + if (cio_tell() - box.init_pos != box.length) { + fprintf(stderr, "Error with FIEL Box size\n"); + return 1; + } + return 0; +} + +/* +* Write the ORFO box +* +* Original Format Box +* +*/ +void mj2_write_orfo(mj2_tk_t * tk) +{ + mj2_box_t box; + + box.init_pos = cio_tell(); + cio_skip(4); + cio_write(MJ2_ORFO, 4); + + cio_write(tk->or_fieldcount, 1); /* Original Field count */ + cio_write(tk->or_fieldorder, 1); /* Original Field order */ + + + box.length = cio_tell() - box.init_pos; + cio_seek(box.init_pos); + cio_write(box.length, 4); /* L */ + cio_seek(box.init_pos + box.length); +} + +/* +* Read the ORFO box +* +* Original Format Box +* +*/ +int mj2_read_orfo(mj2_tk_t * tk) +{ + + mj2_box_t box; + + mj2_read_boxhdr(&box); + if (MJ2_ORFO != box.type) { + fprintf(stderr, "Error: Expected ORFO Marker\n"); + return 1; + } + + + tk->or_fieldcount = cio_read(1); + tk->or_fieldorder = cio_read(1); + + if (cio_tell() - box.init_pos != box.length) { + fprintf(stderr, "Error with ORFO Box size\n"); + return 1; + } + return 0; +} + +/* +* Write the JP2P box +* +* MJP2 Profile Box +* +*/ +void mj2_write_jp2p(mj2_tk_t * tk) +{ + + int i; + mj2_box_t box; + + box.init_pos = cio_tell(); + cio_skip(4); + cio_write(MJ2_JP2P, 4); + + cio_write(0, 4); /* Version 0, flags =0 */ + + for (i = 0; i < tk->num_br; i++) { + cio_write(tk->br[i], 4); + } + + box.length = cio_tell() - box.init_pos; + cio_seek(box.init_pos); + cio_write(box.length, 4); /* L */ + cio_seek(box.init_pos + box.length); +} + +/* +* Read the JP2P box +* +* MJP2 Profile Box +* +*/ +int mj2_read_jp2p(mj2_tk_t * tk) +{ + int i; + + mj2_box_t box; + + mj2_read_boxhdr(&box); + if (MJ2_JP2P != box.type) { + fprintf(stderr, "Error: Expected JP2P Marker\n"); + return 1; + } + + if (0 != cio_read(1)) { /* Version = 0 */ + fprintf(stderr, "Error: Only Version 0 handled in JP2P box\n"); + return 1; + } + + if (0 != cio_read(3)) { /* Flags = 0 */ + fprintf(stderr, "Error with flag in JP2P box. Expected flag 0\n"); + return 1; + } + + + tk->num_br = (box.length - 12) / 4; + tk->br = (unsigned int *) malloc(tk->num_br * sizeof(unsigned int)); + + for (i = 0; i < tk->num_br; i++) { + tk->br[i] = cio_read(4); + } + + if (cio_tell() - box.init_pos != box.length) { + fprintf(stderr, "Error with JP2P Box size\n"); + return 1; + } + return 0; +} + +/* +* Write the JP2X box +* +* MJP2 Prefix Box +* +*/ +void mj2_write_jp2x(mj2_tk_t * tk) +{ + + int i; + mj2_box_t box; + + box.init_pos = cio_tell(); + cio_skip(4); + cio_write(MJ2_JP2X, 4); + + for (i = 0; i < tk->num_jp2x; i++) { + cio_write(tk->jp2xdata[i], 1); + } + + box.length = cio_tell() - box.init_pos; + cio_seek(box.init_pos); + cio_write(box.length, 4); /* L */ + cio_seek(box.init_pos + box.length); +} + +/* +* Read the JP2X box +* +* MJP2 Prefix Box +* +*/ +int mj2_read_jp2x(mj2_tk_t * tk) +{ + unsigned int i; + + mj2_box_t box; + + mj2_read_boxhdr(&box); + if (MJ2_JP2X != box.type) { + fprintf(stderr, "Error: Expected JP2X Marker\n"); + return 1; + } + + + tk->num_jp2x = (box.length - 8); + tk->jp2xdata = + (unsigned char *) malloc(tk->num_jp2x * sizeof(unsigned char)); + + for (i = 0; i < tk->num_jp2x; i++) { + tk->jp2xdata[i] = cio_read(1); + } + + if (cio_tell() - box.init_pos != box.length) { + fprintf(stderr, "Error with JP2X Box size\n"); + return 1; + } + return 0; +} + +/* +* Write the JSUB box +* +* MJP2 Subsampling Box +* +*/ +void mj2_write_jsub(mj2_tk_t * tk) +{ + + mj2_box_t box; + + box.init_pos = cio_tell(); + cio_skip(4); + cio_write(MJ2_JSUB, 4); + + cio_write(tk->hsub, 1); + cio_write(tk->vsub, 1); + cio_write(tk->hoff, 1); + cio_write(tk->voff, 1); + + box.length = cio_tell() - box.init_pos; + cio_seek(box.init_pos); + cio_write(box.length, 4); /* L */ + cio_seek(box.init_pos + box.length); +} + +/* +* Read the JSUB box +* +* MJP2 Subsampling Box +* +*/ +int mj2_read_jsub(mj2_tk_t * tk) +{ + mj2_box_t box; + + mj2_read_boxhdr(&box); + if (MJ2_JSUB != box.type) { + fprintf(stderr, "Error: Expected JSUB Marker\n"); + return 1; + } + + tk->hsub = cio_read(1); + tk->vsub = cio_read(1); + tk->hoff = cio_read(1);; + tk->voff = cio_read(1); + + if (cio_tell() - box.init_pos != box.length) { + fprintf(stderr, "Error with JSUB Box size\n"); + return 1; + } + return 0; +} + +/* +* Write the SMJ2 box +* +* Visual Sample Entry Description +* +*/ +void mj2_write_smj2(mj2_tk_t * tk) +{ + mj2_box_t box; + + box.init_pos = cio_tell(); + cio_skip(4); + cio_write(MJ2_MJ2, 4); /* MJ2 */ + + cio_write(0, 4); /* Version = 0, flags = 0 */ + + cio_write(1, 4); + + cio_write(0, 2); /* Pre-defined */ + + cio_write(0, 2); /* Reserved */ + + cio_write(0, 4); /* Pre-defined */ + cio_write(0, 4); /* Pre-defined */ + cio_write(0, 4); /* Pre-defined */ + + cio_write(tk->w, 2); /* Width */ + cio_write(tk->h, 2); /* Height */ + + cio_write(tk->horizresolution, 4); /* Horizontal resolution */ + cio_write(tk->vertresolution, 4); /* Vertical resolution */ + + cio_write(0, 4); /* Reserved */ + + cio_write(1, 2); /* Pre-defined = 1 */ + + cio_write(tk->compressorname[0], 4); /* Compressor Name */ + cio_write(tk->compressorname[1], 4); + cio_write(tk->compressorname[2], 4); + cio_write(tk->compressorname[3], 4); + cio_write(tk->compressorname[4], 4); + cio_write(tk->compressorname[5], 4); + cio_write(tk->compressorname[6], 4); + cio_write(tk->compressorname[7], 4); + + cio_write(tk->depth, 2); /* Depth */ + + cio_write(0xffff, 2); /* Pre-defined = -1 */ + + jp2_write_jp2h(&tk->jp2_struct); + + mj2_write_fiel(tk); + + if (tk->num_br != 0) + mj2_write_jp2p(tk); + if (tk->num_jp2x != 0) + mj2_write_jp2x(tk); + + mj2_write_jsub(tk); + mj2_write_orfo(tk); + + box.length = cio_tell() - box.init_pos; + cio_seek(box.init_pos); + cio_write(box.length, 4); /* L */ + cio_seek(box.init_pos + box.length); +} + +/* +* Read the SMJ2 box +* +* Visual Sample Entry Description +* +*/ +int mj2_read_smj2(j2k_image_t * img, mj2_tk_t * tk) +{ + mj2_box_t box; + mj2_box_t box2; + int i; + + mj2_read_boxhdr(&box); + + if (MJ2_MJ2 != box.type) { + fprintf(stderr, "Error in SMJ2 box: Expected MJ2 Marker\n"); + return 1; + } + + if (0 != cio_read(1)) { /* Version = 0 */ + fprintf(stderr, "Error: Only Version 0 handled in MJP2 box\n"); + return 1; + } + + if (0 != cio_read(3)) { /* Flags = 0 */ + fprintf(stderr, "Error with flag in MJP2 box. Expected flag 0\n"); + return 1; + } + + cio_skip(4); + + cio_skip(2); /* Pre-defined */ + + cio_skip(2); /* Reserved */ + + cio_skip(4); /* Pre-defined */ + cio_skip(4); /* Pre-defined */ + cio_skip(4); /* Pre-defined */ + + tk->w = cio_read(2); /* Width */ + tk->h = cio_read(2); /* Height */ + + tk->horizresolution = cio_read(4); /* Horizontal resolution */ + tk->vertresolution = cio_read(4); /* Vertical resolution */ + + cio_skip(4); /* Reserved */ + + cio_skip(2); /* Pre-defined = 1 */ + + tk->compressorname[0] = cio_read(4); /* Compressor Name */ + tk->compressorname[1] = cio_read(4); + tk->compressorname[2] = cio_read(4); + tk->compressorname[3] = cio_read(4); + tk->compressorname[4] = cio_read(4); + tk->compressorname[5] = cio_read(4); + tk->compressorname[6] = cio_read(4); + tk->compressorname[7] = cio_read(4); + + tk->depth = cio_read(2); /* Depth */ + + /* Init std value */ + tk->num_jp2x = 0; + tk->fieldcount = 1; + tk->fieldorder = 0; + tk->or_fieldcount = 1; + tk->or_fieldorder = 0; + + cio_skip(2); /* Pre-defined = -1 */ + + if (jp2_read_jp2h(&tk->jp2_struct)) { + fprintf(stderr, "Error with JP2H Box\n"); + return 1; + } + + tk->jp2_struct.comps = (jp2_comps_t *) malloc(tk->jp2_struct.numcomps * sizeof(jp2_comps_t)); + tk->jp2_struct.cl = (int *) malloc(sizeof(int)); + + tk->num_br = 0; + tk->num_jp2x = 0; + + for (i = 0; cio_tell() - box.init_pos < box.length; i++) { + mj2_read_boxhdr(&box2); + cio_seek(box2.init_pos); + switch (box2.type) { + case MJ2_FIEL: + if (mj2_read_fiel(tk)) + return 1; + break; + + case MJ2_JP2P: + if (mj2_read_jp2p(tk)) + return 1; + break; + + case MJ2_JP2X: + if (mj2_read_jp2x(tk)) + return 1; + break; + + case MJ2_JSUB: + if (mj2_read_jsub(tk)) + return 1; + break; + + case MJ2_ORFO: + if (mj2_read_orfo(tk)) + return 1; + break; + + default: + fprintf(stderr, "Error with MJP2 Box size\n"); + return 1; + break; + + } + } + return 0; +} + + +/* +* Write the STSD box +* +* Sample Description +* +*/ +void mj2_write_stsd(mj2_tk_t * tk) +{ + mj2_box_t box; + + box.init_pos = cio_tell(); + cio_skip(4); + cio_write(MJ2_STSD, 4); /* STSD */ + + cio_write(0, 4); /* Version = 0, flags = 0 */ + + cio_write(1, 4); /* entry_count = 1 (considering same JP2 headerboxes) */ + + if (tk->track_type == 0) { + mj2_write_smj2(tk); + } else if (tk->track_type == 1) { + // Not implemented + } + if (tk->track_type == 2) { + // Not implemented + } + + + box.length = cio_tell() - box.init_pos; + cio_seek(box.init_pos); + cio_write(box.length, 4); /* L */ + cio_seek(box.init_pos + box.length); +} + +/* +* Read the STSD box +* +* Sample Description +* +*/ +int mj2_read_stsd(mj2_tk_t * tk, j2k_image_t * img) +{ + int i; + int entry_count, len_2skip; + + mj2_box_t box; + + mj2_read_boxhdr(&box); + + if (MJ2_STSD != box.type) { + fprintf(stderr, "Error: Expected STSD Marker\n"); + return 1; + } + + if (0 != cio_read(1)) { /* Version = 0 */ + fprintf(stderr, "Error: Only Version 0 handled in STSD box\n"); + return 1; + } + + if (0 != cio_read(3)) { /* Flags = 0 */ + fprintf(stderr, "Error with flag in STSD box. Expected flag 0\n"); + return 1; + } + + entry_count = cio_read(4); + + if (tk->track_type == 0) { + for (i = 0; i < entry_count; i++) { + if (mj2_read_smj2(img, tk)) + return 1; + } + } else if (tk->track_type == 1) { + len_2skip = cio_read(4); // Not implemented -> skipping box + cio_skip(len_2skip - 4); + } else if (tk->track_type == 2) { + len_2skip = cio_read(4); // Not implemented -> skipping box + cio_skip(len_2skip - 4); + } + + + if (cio_tell() - box.init_pos != box.length) { + fprintf(stderr, "Error with STSD Box size\n"); + return 1; + } + return 0; +} + +/* +* Write the STBL box +* +* Sample table box box +* +*/ +void mj2_write_stbl(mj2_tk_t * tk) +{ + mj2_box_t box; + + box.init_pos = cio_tell(); + cio_skip(4); + cio_write(MJ2_STBL, 4); /* STBL */ + + mj2_write_stsd(tk); + mj2_write_stts(tk); + mj2_write_stsc(tk); + mj2_write_stsz(tk); + mj2_write_stco(tk); + + box.length = cio_tell() - box.init_pos; + cio_seek(box.init_pos); + cio_write(box.length, 4); /* L */ + cio_seek(box.init_pos + box.length); +} + +/* +* Read the STBL box +* +* Sample table box box +* +*/ +int mj2_read_stbl(mj2_tk_t * tk, j2k_image_t * img) +{ + mj2_box_t box; + + mj2_read_boxhdr(&box); + if (MJ2_STBL != box.type) { + fprintf(stderr, "Error: Expected STBL Marker\n"); + return 1; + } + + if (mj2_read_stsd(tk, img)) + return 1; + if (mj2_read_stts(tk)) + return 1; + if (mj2_read_stsc(tk)) + return 1; + if (mj2_read_stsz(tk)) + return 1; + if (mj2_read_stco(tk)) + return 1; + + if (cio_tell() - box.init_pos != box.length) { + fprintf(stderr, "Error with STBL Box size\n"); + return 1; + } + return 0; +} + +/* +* Write the URL box +* +* URL box +* +*/ +void mj2_write_url(mj2_tk_t * tk, int url_num) +{ + mj2_box_t box; + + box.init_pos = cio_tell(); + cio_skip(4); + cio_write(MJ2_URL, 4); /* URL */ + + if (url_num == 0) + cio_write(1, 4); /* Version = 0, flags = 1 because stored in same file */ + else { + cio_write(0, 4); /* Version = 0, flags = 0 */ + cio_write(tk->url[url_num - 1].location[0], 4); + cio_write(tk->url[url_num - 1].location[1], 4); + cio_write(tk->url[url_num - 1].location[2], 4); + cio_write(tk->url[url_num - 1].location[3], 4); + } + + box.length = cio_tell() - box.init_pos; + cio_seek(box.init_pos); + cio_write(box.length, 4); /* L */ + cio_seek(box.init_pos + box.length); +} + +/* +* Read the URL box +* +* URL box +* +*/ +int mj2_read_url(mj2_tk_t * tk, int urn_num) +{ + mj2_box_t box; + + mj2_read_boxhdr(&box); + if (MJ2_URL != box.type) { + fprintf(stderr, "Error: Expected URL Marker\n"); + return 1; + } + + if (0 != cio_read(1)) { /* Version = 0 */ + fprintf(stderr, "Error: Only Version 0 handled in URL box\n"); + return 1; + } + + if (1 != cio_read(3)) { /* If flags = 1 --> media data in file */ + tk->url[urn_num].location[0] = cio_read(4); + tk->url[urn_num].location[1] = cio_read(4); + tk->url[urn_num].location[2] = cio_read(4); + tk->url[urn_num].location[3] = cio_read(4); + } else { + tk->num_url--; + } + + + if (cio_tell() - box.init_pos != box.length) { + fprintf(stderr, "Error with URL Box size\n"); + return 1; + } + return 0; +} + +/* +* Write the URN box +* +* URN box +* +*/ +void mj2_write_urn(mj2_tk_t * tk, int urn_num) +{ + mj2_box_t box; + + box.init_pos = cio_tell(); + cio_skip(4); + cio_write(MJ2_URN, 4); /* URN */ + + cio_write(0, 4); /* Version = 0, flags = 0 */ + + cio_write(tk->urn[urn_num].name[0], 4); + cio_write(tk->urn[urn_num].name[1], 4); + cio_write(tk->urn[urn_num].name[2], 4); + cio_write(tk->urn[urn_num].name[3], 4); + cio_write(tk->urn[urn_num].location[0], 4); + cio_write(tk->urn[urn_num].location[1], 4); + cio_write(tk->urn[urn_num].location[2], 4); + cio_write(tk->urn[urn_num].location[3], 4); + + box.length = cio_tell() - box.init_pos; + cio_seek(box.init_pos); + cio_write(box.length, 4); /* L */ + cio_seek(box.init_pos + box.length); +} + +/* +* Read the URN box +* +* URN box +* +*/ +int mj2_read_urn(mj2_tk_t * tk, int urn_num) +{ + + mj2_box_t box; + + mj2_read_boxhdr(&box); + if (MJ2_URN != box.type) { + fprintf(stderr, "Error: Expected URN Marker\n"); + return 1; + } + + if (0 != cio_read(1)) { /* Version = 0 */ + fprintf(stderr, "Error: Only Version 0 handled in URN box\n"); + return 1; + } + + if (1 != cio_read(3)) { /* If flags = 1 --> media data in file */ + tk->urn[urn_num].name[0] = cio_read(4); + tk->urn[urn_num].name[1] = cio_read(4); + tk->urn[urn_num].name[2] = cio_read(4); + tk->urn[urn_num].name[3] = cio_read(4); + tk->urn[urn_num].location[0] = cio_read(4); + tk->urn[urn_num].location[1] = cio_read(4); + tk->urn[urn_num].location[2] = cio_read(4); + tk->urn[urn_num].location[3] = cio_read(4); + } + + + if (cio_tell() - box.init_pos != box.length) { + fprintf(stderr, "Error with URN Box size\n"); + return 1; + } + return 0; +} + + +/* +* Write the DREF box +* +* Data reference box +* +*/ +void mj2_write_dref(mj2_tk_t * tk) +{ + int i; + mj2_box_t box; + + box.init_pos = cio_tell(); + cio_skip(4); + cio_write(MJ2_DREF, 4); /* DREF */ + + cio_write(0, 4); /* Version = 0, flags = 0 */ + + if (tk->num_url + tk->num_urn == 0) { /* Media data in same file */ + cio_write(1, 4); /* entry_count = 1 */ + mj2_write_url(tk, 0); + } else { + cio_write(tk->num_url + tk->num_urn, 4); /* entry_count */ + + for (i = 0; i < tk->num_url; i++) + mj2_write_url(tk, i + 1); + + for (i = 0; i < tk->num_urn; i++) + mj2_write_urn(tk, i); + } + + box.length = cio_tell() - box.init_pos; + cio_seek(box.init_pos); + cio_write(box.length, 4); /* L */ + cio_seek(box.init_pos + box.length); +} + +/* +* Read the DREF box +* +* Data reference box +* +*/ +int mj2_read_dref(mj2_tk_t * tk) +{ + + int i; + int entry_count, marker; + mj2_box_t box; + + mj2_read_boxhdr(&box); + if (MJ2_DREF != box.type) { + fprintf(stderr, "Error: Expected DREF Marker\n"); + return 1; + } + + if (0 != cio_read(1)) { /* Version = 0 */ + fprintf(stderr, "Error: Only Version 0 handled in DREF box\n"); + return 1; + } + + if (0 != cio_read(3)) { /* Flags = 0 */ + fprintf(stderr, "Error with flag in DREF box. Expected flag 0\n"); + return 1; + } + + entry_count = cio_read(4); + tk->num_url = 0; + tk->num_urn = 0; + + for (i = 0; i < entry_count; i++) { + cio_skip(4); + marker = cio_read(4); + if (marker == MJ2_URL) { + cio_skip(-8); + tk->num_url++; + if (mj2_read_url(tk, tk->num_url)) + return 1; + } else if (marker == MJ2_URN) { + cio_skip(-8); + tk->num_urn++; + if (mj2_read_urn(tk, tk->num_urn)) + return 1; + } else { + fprintf(stderr, "Error with in DREF box. Expected URN or URL box\n"); + return 1; + } + + } + + + if (cio_tell() - box.init_pos != box.length) { + fprintf(stderr, "Error with DREF Box size\n"); + return 1; + } + return 0; +} + +/* +* Write the DINF box +* +* Data information box +* +*/ +void mj2_write_dinf(mj2_tk_t * tk) +{ + mj2_box_t box; + + box.init_pos = cio_tell(); + cio_skip(4); + cio_write(MJ2_DINF, 4); /* DINF */ + + mj2_write_dref(tk); + + box.length = cio_tell() - box.init_pos; + cio_seek(box.init_pos); + cio_write(box.length, 4); /* L */ + cio_seek(box.init_pos + box.length); +} + +/* +* Read the DINF box +* +* Data information box +* +*/ +int mj2_read_dinf(mj2_tk_t * tk) +{ + mj2_box_t box; + + mj2_read_boxhdr(&box); + if (MJ2_DINF != box.type) { + fprintf(stderr, "Error: Expected DINF Marker\n"); + return 1; + } + + if (mj2_read_dref(tk)) + return 1; + + if (cio_tell() - box.init_pos != box.length) { + fprintf(stderr, "Error with DINF Box size\n"); + return 1; + } + return 0; +} + +/* +* Write the VMHD box +* +* Video Media information box +* +*/ +void mj2_write_vmhd(mj2_tk_t * tk) +{ + mj2_box_t box; + + box.init_pos = cio_tell(); + cio_skip(4); + cio_write(MJ2_VMHD, 4); /* VMHD */ + + cio_write(1, 4); /* Version = 0, flags = 1 */ + + cio_write(tk->graphicsmode, 2); + cio_write(tk->opcolor[0], 2); + cio_write(tk->opcolor[1], 2); + cio_write(tk->opcolor[2], 2); + + box.length = cio_tell() - box.init_pos; + cio_seek(box.init_pos); + cio_write(box.length, 4); /* L */ + cio_seek(box.init_pos + box.length); +} + +/* +* Read the VMHD box +* +* Video Media information box +* +*/ +int mj2_read_vmhd(mj2_tk_t * tk) +{ + mj2_box_t box; + + mj2_read_boxhdr(&box); + if (MJ2_VMHD != box.type) { + fprintf(stderr, "Error: Expected VMHD Marker\n"); + return 1; + } + + if (0 != cio_read(1)) { /* Version = 0 */ + fprintf(stderr, "Error: Only Version 0 handled in VMHD box\n"); + return 1; + } + + if (1 != cio_read(3)) { /* Flags = 1 */ + fprintf(stderr, "Error with flag in VMHD box. Expected flag 1\n"); + return 1; + } + + tk->track_type = 0; + tk->graphicsmode = cio_read(2); + tk->opcolor[0] = cio_read(2); + tk->opcolor[1] = cio_read(2); + tk->opcolor[2] = cio_read(2); + + if (cio_tell() - box.init_pos != box.length) { + fprintf(stderr, "Error with VMHD Box size\n"); + return 1; + } + return 0; +} + +/* +* Write the SMHD box +* +* Sound Media information box +* +*/ +void mj2_write_smhd(mj2_tk_t * tk) +{ + mj2_box_t box; + + box.init_pos = cio_tell(); + cio_skip(4); + cio_write(MJ2_SMHD, 4); /* SMHD */ + + cio_write(0, 4); /* Version = 0, flags = 0 */ + + cio_write(tk->balance, 2); + + cio_write(0, 2); /* Reserved */ + + box.length = cio_tell() - box.init_pos; + cio_seek(box.init_pos); + cio_write(box.length, 4); /* L */ + cio_seek(box.init_pos + box.length); +} + +/* +* Read the SMHD box +* +* Sound Media information box +* +*/ +int mj2_read_smhd(mj2_tk_t * tk) +{ + mj2_box_t box; + + mj2_read_boxhdr(&box); + if (MJ2_SMHD != box.type) { + fprintf(stderr, "Error: Expected SMHD Marker\n"); + return 1; + } + + if (0 != cio_read(1)) { /* Version = 0 */ + fprintf(stderr, "Error: Only Version 0 handled in SMHD box\n"); + return 1; + } + + if (0 != cio_read(3)) { /* Flags = 0 */ + fprintf(stderr, "Error with flag in SMHD box. Expected flag 0\n"); + return 1; + } + + tk->track_type = 1; + tk->balance = cio_read(2); + + /* Init variables to zero to avoid problems when freeeing memory + The values will possibly be overidded when decoding the track structure */ + tk->num_br = 0; + tk->num_url = 0; + tk->num_urn = 0; + tk->num_chunks = 0; + tk->num_tts = 0; + tk->num_samplestochunk = 0; + tk->num_samples = 0; + + cio_skip(2); /* Reserved */ + + if (cio_tell() - box.init_pos != box.length) { + fprintf(stderr, "Error with SMHD Box size\n"); + return 1; + } + return 0; +} + +/* +* Write the HMHD box +* +* Hint Media information box +* +*/ +void mj2_write_hmhd(mj2_tk_t * tk) +{ + mj2_box_t box; + + box.init_pos = cio_tell(); + cio_skip(4); + cio_write(MJ2_HMHD, 4); /* HMHD */ + + cio_write(0, 4); /* Version = 0, flags = 0 */ + + cio_write(tk->maxPDUsize, 2); + cio_write(tk->avgPDUsize, 2); + cio_write(tk->maxbitrate, 4); + cio_write(tk->avgbitrate, 4); + cio_write(tk->slidingavgbitrate, 4); + + box.length = cio_tell() - box.init_pos; + cio_seek(box.init_pos); + cio_write(box.length, 4); /* L */ + cio_seek(box.init_pos + box.length); +} + +/* +* Read the HMHD box +* +* Hint Media information box +* +*/ +int mj2_read_hmhd(mj2_tk_t * tk) +{ + mj2_box_t box; + + mj2_read_boxhdr(&box); + if (MJ2_HMHD != box.type) { + fprintf(stderr, "Error: Expected HMHD Marker\n"); + return 1; + } + + if (0 != cio_read(1)) { /* Version = 0 */ + fprintf(stderr, "Error: Only Version 0 handled in HMHD box\n"); + return 1; + } + + if (0 != cio_read(3)) { /* Flags = 0 */ + fprintf(stderr, "Error with flag in HMHD box. Expected flag 0\n"); + return 1; + } + + tk->track_type = 2; + tk->maxPDUsize = cio_read(2); + tk->avgPDUsize = cio_read(2); + tk->maxbitrate = cio_read(4); + tk->avgbitrate = cio_read(4); + tk->slidingavgbitrate = cio_read(4); + + /* Init variables to zero to avoid problems when freeeing memory + The values will possibly be overidded when decoding the track structure */ + tk->num_br = 0; + tk->num_url = 0; + tk->num_urn = 0; + tk->num_chunks = 0; + tk->num_tts = 0; + tk->num_samplestochunk = 0; + tk->num_samples = 0; + + + if (cio_tell() - box.init_pos != box.length) { + fprintf(stderr, "Error with HMHD Box size\n"); + return 1; + } + return 0; +} + +/* +* Write the MINF box +* +* Media information box +* +*/ +void mj2_write_minf(mj2_tk_t * tk) +{ + mj2_box_t box; + + box.init_pos = cio_tell(); + cio_skip(4); + cio_write(MJ2_MINF, 4); /* MINF */ + + if (tk->track_type == 0) { + mj2_write_vmhd(tk); + } else if (tk->track_type == 1) { + mj2_write_smhd(tk); + } else if (tk->track_type == 2) { + mj2_write_hmhd(tk); + } + + mj2_write_dinf(tk); + mj2_write_stbl(tk); + + box.length = cio_tell() - box.init_pos; + cio_seek(box.init_pos); + cio_write(box.length, 4); /* L */ + cio_seek(box.init_pos + box.length); +} + +/* +* Read the MINF box +* +* Media information box +* +*/ +int mj2_read_minf(mj2_tk_t * tk, j2k_image_t * img) +{ + + unsigned int box_type; + mj2_box_t box; + + mj2_read_boxhdr(&box); + if (MJ2_MINF != box.type) { + fprintf(stderr, "Error: Expected MINF Marker\n"); + return 1; + } + + cio_skip(4); + box_type = cio_read(4); + cio_skip(-8); + + if (box_type == MJ2_VMHD) { + if (mj2_read_vmhd(tk)) + return 1; + } else if (box_type == MJ2_SMHD) { + if (mj2_read_smhd(tk)) + return 1; + } else if (box_type == MJ2_HMHD) { + if (mj2_read_hmhd(tk)) + return 1; + } else { + fprintf(stderr, "Error in MINF box expected vmhd, smhd or hmhd\n"); + return 1; + } + + if (mj2_read_dinf(tk)) + return 1; + + if (mj2_read_stbl(tk, img)) + return 1; + + if (cio_tell() - box.init_pos != box.length) { + fprintf(stderr, "Error with MINF Box size\n"); + return 1; + } + return 0; +} + +/* +* Write the HDLR box +* +* Handler reference box +* +*/ +void mj2_write_hdlr(mj2_tk_t * tk) +{ + mj2_box_t box; + + box.init_pos = cio_tell(); + cio_skip(4); + cio_write(MJ2_HDLR, 4); /* HDLR */ + + cio_write(0, 4); /* Version = 0, flags = 0 */ + + cio_write(0, 4); /* Predefine */ + + tk->name = 0; /* The track name is immediately determined by the track type */ + + if (tk->track_type == 0) { + tk->handler_type = 0x76696465; /* Handler type: vide */ + cio_write(tk->handler_type, 4); + + cio_write(0, 4); + cio_write(0, 4); + cio_write(0, 4); /* Reserved */ + + cio_write(0x76696465, 4); + cio_write(0x6F206d65, 4); + cio_write(0x64696120, 4); + cio_write(0x74726163, 4); + cio_write(0x6b00, 2); /* String: video media track */ + } else if (tk->track_type == 1) { + tk->handler_type = 0x736F756E; /* Handler type: soun */ + cio_write(tk->handler_type, 4); + + cio_write(0, 4); + cio_write(0, 4); + cio_write(0, 4); /* Reserved */ + + cio_write(0x536F756E, 4); + cio_write(0x6400, 2); /* String: Sound */ + } else if (tk->track_type == 2) { + tk->handler_type = 0x68696E74; /* Handler type: hint */ + cio_write(tk->handler_type, 4); + + cio_write(0, 4); + cio_write(0, 4); + cio_write(0, 4); /* Reserved */ + + cio_write(0x48696E74, 4); + cio_write(0, 2); /* String: Hint */ + } + + box.length = cio_tell() - box.init_pos; + cio_seek(box.init_pos); + cio_write(box.length, 4); /* L */ + cio_seek(box.init_pos + box.length); +} + +/* +* Read the HDLR box +* +* Handler reference box +* +*/ +int mj2_read_hdlr(mj2_tk_t * tk) +{ + int i; + mj2_box_t box; + + mj2_read_boxhdr(&box); + if (MJ2_HDLR != box.type) { + fprintf(stderr, "Error: Expected HDLR Marker\n"); + return 1; + } + + + if (0 != cio_read(1)) { /* Version = 0 */ + fprintf(stderr, "Error: Only Version 0 handled in HDLR box\n"); + return 1; + } + + if (0 != cio_read(3)) { /* Flags = 0 */ + fprintf(stderr, "Error with flag in HDLR box. Expected flag 0\n"); + return 1; + } + + cio_skip(4); /* Reserved */ + + tk->handler_type = cio_read(4); + cio_skip(12); /* Reserved */ + + tk->name_size = box.length - 32; + + tk->name = (char *) malloc(tk->name_size * sizeof(char)); + for (i = 0; i < tk->name_size; i++) { + tk->name[i] = cio_read(1); /* Name */ + } + + if (cio_tell() - box.init_pos != box.length) { + fprintf(stderr, "Error with HDLR Box size\n"); + return 1; + } + return 0; +} + +/* +* Write the MDHD box +* +* Media Header Box +* +*/ +void mj2_write_mdhd(mj2_tk_t * tk) +{ + mj2_box_t box; + unsigned int i; + time_t ltime; + unsigned int modification_time; + + box.init_pos = cio_tell(); + cio_skip(4); + cio_write(MJ2_MDHD, 4); /* MDHD */ + + cio_write(0, 4); /* Version = 0, flags = 0 */ + + cio_write(tk->creation_time, 4); /* Creation Time */ + + time(<ime); /* Time since 1/1/70 */ + modification_time = ltime + 2082844800; /* Seoonds between 1/1/04 and 1/1/70 */ + + cio_write(modification_time, 4); /* Modification Time */ + + cio_write(tk->timescale, 4); /* Timescale */ + + tk->duration = 0; + + for (i = 0; i < tk->num_samples; i++) + tk->duration += tk->sample[i].sample_delta; + + cio_write(tk->duration, 4); /* Duration */ + + cio_write(tk->language, 2); /* Language */ + + cio_write(0, 2); /* Predefined */ + + box.length = cio_tell() - box.init_pos; + cio_seek(box.init_pos); + cio_write(box.length, 4); /* L */ + cio_seek(box.init_pos + box.length); +} + +/* +* Read the MDHD box +* +* Media Header Box +* +*/ +int mj2_read_mdhd(mj2_tk_t * tk) +{ + mj2_box_t box; + + mj2_read_boxhdr(&box); + if (!(MJ2_MHDR == box.type || MJ2_MDHD == box.type)) { // Kakadu writes MHDR instead of MDHD + fprintf(stderr, "Error: Expected MDHD Marker\n"); + return 1; + } + + if (0 != cio_read(1)) { /* Version = 0 */ + fprintf(stderr, "Error: Only Version 0 handled in MDHD box\n"); + return 1; + } + + if (0 != cio_read(3)) { /* Flags = 0 */ + fprintf(stderr, "Error with flag in MDHD box. Expected flag 0\n"); + return 1; + } + + + tk->creation_time = cio_read(4); /* Creation Time */ + + tk->modification_time = cio_read(4); /* Modification Time */ + + tk->timescale = cio_read(4); /* Timescale */ + + tk->duration = cio_read(4); /* Duration */ + + tk->language = cio_read(2); /* Language */ + + cio_skip(2); /* Predefined */ + + if (cio_tell() - box.init_pos != box.length) { + fprintf(stderr, "Error with MDHD Box size\n"); + return 1; + } + return 0; +} + +/* +* Write the MDIA box +* +* Media box +* +*/ +void mj2_write_mdia(mj2_tk_t * tk) +{ + mj2_box_t box; + + box.init_pos = cio_tell(); + cio_skip(4); + cio_write(MJ2_MDIA, 4); /* MDIA */ + + mj2_write_mdhd(tk); + mj2_write_hdlr(tk); + mj2_write_minf(tk); + + box.length = cio_tell() - box.init_pos; + cio_seek(box.init_pos); + cio_write(box.length, 4); /* L */ + cio_seek(box.init_pos + box.length); +} + +/* +* Read the MDIA box +* +* Media box +* +*/ +int mj2_read_mdia(mj2_tk_t * tk, j2k_image_t * img) +{ + mj2_box_t box; + + mj2_read_boxhdr(&box); + if (MJ2_MDIA != box.type) { + fprintf(stderr, "Error: Expected MDIA Marker\n"); + return 1; + } + + if (mj2_read_mdhd(tk)) + return 1; + if (mj2_read_hdlr(tk)) + return 1; + if (mj2_read_minf(tk, img)) + return 1; + + if (cio_tell() - box.init_pos != box.length) { + fprintf(stderr, "Error with MDIA Box size\n"); + return 1; + } + return 0; +} + +/* +* Write the TKHD box +* +* Track Header box +* +*/ +void mj2_write_tkhd(mj2_tk_t * tk) +{ + mj2_box_t box; + unsigned int i; + time_t ltime; + + box.init_pos = cio_tell(); + cio_skip(4); + + cio_write(MJ2_TKHD, 4); /* TKHD */ + + cio_write(3, 4); /* Version=0, flags=3 */ + + time(<ime); /* Time since 1/1/70 */ + tk->modification_time = ltime + 2082844800; /* Seoonds between 1/1/04 and 1/1/70 */ + + cio_write(tk->creation_time, 4); /* Creation Time */ + + cio_write(tk->modification_time, 4); /* Modification Time */ + + cio_write(tk->track_ID, 4); /* Track ID */ + + cio_write(0, 4); /* Reserved */ + + tk->duration = 0; + + for (i = 0; i < tk->num_samples; i++) + tk->duration += tk->sample[i].sample_delta; + + cio_write(tk->duration, 4); /* Duration */ + + cio_write(0, 4); /* Reserved */ + cio_write(0, 4); /* Reserved */ + + cio_write(tk->layer, 2); /* Layer */ + + cio_write(0, 2); /* Predefined */ + + cio_write(tk->volume, 2); /* Volume */ + + cio_write(0, 2); /* Reserved */ + + cio_write(tk->trans_matrix[0], 4); /* Transformation matrix for track */ + cio_write(tk->trans_matrix[1], 4); + cio_write(tk->trans_matrix[2], 4); + cio_write(tk->trans_matrix[3], 4); + cio_write(tk->trans_matrix[4], 4); + cio_write(tk->trans_matrix[5], 4); + cio_write(tk->trans_matrix[6], 4); + cio_write(tk->trans_matrix[7], 4); + cio_write(tk->trans_matrix[8], 4); + + cio_write(tk->visual_w, 4); /* Video Visual Width */ + + cio_write(tk->visual_h, 4); /* Video Visual Height */ + + box.length = cio_tell() - box.init_pos; + cio_seek(box.init_pos); + cio_write(box.length, 4); /* L */ + cio_seek(box.init_pos + box.length); +} + +/* +* Read the TKHD box +* +* Track Header box +* +*/ +int mj2_read_tkhd(mj2_tk_t * tk) +{ + int flag; + + mj2_box_t box; + + mj2_read_boxhdr(&box); + + if (MJ2_TKHD != box.type) { + fprintf(stderr, "Error: Expected TKHD Marker\n"); + return 1; + } + + if (0 != cio_read(1)) { /* Version = 0 */ + fprintf(stderr, "Error: Only Version 0 handled in TKHD box\n"); + return 1; + } + + flag = cio_read(3); + + if (!(flag == 1 || flag == 2 || flag == 3 || flag == 4)) { /* Flags = 1,2,3 or 4 */ + fprintf(stderr, + "Error with flag in TKHD box: Expected flag 1,2,3 or 4\n"); + return 1; + } + + tk->creation_time = cio_read(4); /* Creation Time */ + + tk->modification_time = cio_read(4); /* Modification Time */ + + tk->track_ID = cio_read(4); /* Track ID */ + + cio_skip(4); /* Reserved */ + + tk->duration = cio_read(4); /* Duration */ + + cio_skip(8); /* Reserved */ + + tk->layer = cio_read(2); /* Layer */ + + cio_read(2); /* Predefined */ + + tk->volume = cio_read(2); /* Volume */ + + cio_skip(2); /* Reserved */ + + tk->trans_matrix[0] = cio_read(4); /* Transformation matrix for track */ + tk->trans_matrix[1] = cio_read(4); + tk->trans_matrix[2] = cio_read(4); + tk->trans_matrix[3] = cio_read(4); + tk->trans_matrix[4] = cio_read(4); + tk->trans_matrix[5] = cio_read(4); + tk->trans_matrix[6] = cio_read(4); + tk->trans_matrix[7] = cio_read(4); + tk->trans_matrix[8] = cio_read(4); + + tk->visual_w = cio_read(4); /* Video Visual Width */ + + tk->visual_h = cio_read(4); /* Video Visual Height */ + + if (cio_tell() - box.init_pos != box.length) { + fprintf(stderr, "Error with TKHD Box size\n"); + return 1; + } + return 0; +} + +/* +* Write the TRAK box +* +* Track box +* +*/ +void mj2_write_trak(mj2_tk_t * tk) +{ + mj2_box_t box; + + box.init_pos = cio_tell(); + cio_skip(4); + + cio_write(MJ2_TRAK, 4); /* TRAK */ + + mj2_write_tkhd(tk); + mj2_write_mdia(tk); + + box.length = cio_tell() - box.init_pos; + cio_seek(box.init_pos); + cio_write(box.length, 4); /* L */ + cio_seek(box.init_pos + box.length); +} + +/* +* Read the TRAK box +* +* Track box +* +*/ +int mj2_read_trak(mj2_tk_t * tk, j2k_image_t * img) +{ + mj2_box_t box; + + mj2_read_boxhdr(&box); + if (MJ2_TRAK != box.type) { + fprintf(stderr, "Error: Expected TRAK Marker\n"); + return 1; + } + if (mj2_read_tkhd(tk)) + return 1; + if (mj2_read_mdia(tk, img)) + return 1; + if (cio_tell() - box.init_pos != box.length) { + fprintf(stderr, "Error with TRAK Box\n"); + return 1; + } + return 0; +} + +/* +* Write the MVHD box +* +* Movie header Box +* +*/ +void mj2_write_mvhd(mj2_movie_t * movie) +{ + int i; + mj2_box_t box; + unsigned j; + time_t ltime; + int max_tk_num = 0; + + box.init_pos = cio_tell(); + cio_skip(4); + cio_write(MJ2_MVHD, 4); /* MVHD */ + + cio_write(0, 4); /* Version = 0, flags = 0 */ + + time(<ime); /* Time since 1/1/70 */ + movie->modification_time = ltime + 2082844800; /* Seoonds between 1/1/04 and 1/1/70 */ + + cio_write(movie->creation_time, 4); /* Creation Time */ + + cio_write(movie->modification_time, 4); /* Modification Time */ + + cio_write(movie->timescale, 4); /* Timescale */ + + movie->duration = 0; + + for (i = 0; i < (movie->num_stk + movie->num_htk + movie->num_vtk); i++) { + mj2_tk_t *tk = &movie->tk[i]; + + for (j = 0; j < tk->num_samples; j++) { + movie->duration += tk->sample[j].sample_delta; + } + } + + cio_write(movie->duration, 4); + + cio_write(movie->rate, 4); /* Rate to play presentation */ + + cio_write(movie->volume, 2); /* Volume */ + + cio_write(0, 2); /* Reserved */ + cio_write(0, 4); /* Reserved */ + cio_write(0, 4); /* Reserved */ + + cio_write(movie->trans_matrix[0], 4); /* Transformation matrix for video */ + cio_write(movie->trans_matrix[1], 4); + cio_write(movie->trans_matrix[2], 4); + cio_write(movie->trans_matrix[3], 4); + cio_write(movie->trans_matrix[4], 4); + cio_write(movie->trans_matrix[5], 4); + cio_write(movie->trans_matrix[6], 4); + cio_write(movie->trans_matrix[7], 4); + cio_write(movie->trans_matrix[8], 4); + + cio_write(0, 4); /* Pre-defined */ + cio_write(0, 4); /* Pre-defined */ + cio_write(0, 4); /* Pre-defined */ + cio_write(0, 4); /* Pre-defined */ + cio_write(0, 4); /* Pre-defined */ + cio_write(0, 4); /* Pre-defined */ + + + for (i = 0; i < movie->num_htk + movie->num_stk + movie->num_vtk; i++) { + if (max_tk_num < movie->tk[i].track_ID) + max_tk_num = movie->tk[i].track_ID; + } + + movie->next_tk_id = max_tk_num + 1; + + cio_write(movie->next_tk_id, 4); /* ID of Next track to be added */ + + box.length = cio_tell() - box.init_pos; + cio_seek(box.init_pos); + cio_write(box.length, 4); /* L */ + cio_seek(box.init_pos + box.length); +} + +/* +* Read the MVHD box +* +* Movie header Box +* +*/ +int mj2_read_mvhd(mj2_movie_t * movie) +{ + mj2_box_t box; + + mj2_read_boxhdr(&box); + if (MJ2_MVHD != box.type) { + fprintf(stderr, "Error: Expected MVHD Marker\n"); + return 1; + } + + + if (0 != cio_read(4)) { /* Version = 0, flags = 0 */ + fprintf(stderr, "Error: Only Version 0 handled in MVHD box\n"); + } + + movie->creation_time = cio_read(4); /* Creation Time */ + + movie->modification_time = cio_read(4); /* Modification Time */ + + movie->timescale = cio_read(4); /* Timescale */ + + movie->duration = cio_read(4); /* Duration */ + + movie->rate = cio_read(4); /* Rate to play presentation */ + + movie->volume = cio_read(2); /* Volume */ + + cio_skip(10); /* Reserved */ + + movie->trans_matrix[0] = cio_read(4); /* Transformation matrix for video */ + movie->trans_matrix[1] = cio_read(4); + movie->trans_matrix[2] = cio_read(4); + movie->trans_matrix[3] = cio_read(4); + movie->trans_matrix[4] = cio_read(4); + movie->trans_matrix[5] = cio_read(4); + movie->trans_matrix[6] = cio_read(4); + movie->trans_matrix[7] = cio_read(4); + movie->trans_matrix[8] = cio_read(4); + + cio_skip(24); /* Pre-defined */ + + movie->next_tk_id = cio_read(4); /* ID of Next track to be added */ + + if (cio_tell() - box.init_pos != box.length) { + fprintf(stderr, "Error with MVHD Box Size\n"); + return 1; + } + return 0; +} + + +/* +* Write the MOOV box +* +* Movie Box +* +*/ +void mj2_write_moov(mj2_movie_t * movie) +{ + int i; + mj2_box_t box; + + box.init_pos = cio_tell(); + cio_skip(4); + cio_write(MJ2_MOOV, 4); /* MOOV */ + + mj2_write_mvhd(movie); + + for (i = 0; i < (movie->num_stk + movie->num_htk + movie->num_vtk); i++) { + mj2_write_trak(&movie->tk[i]); + } + + box.length = cio_tell() - box.init_pos; + cio_seek(box.init_pos); + cio_write(box.length, 4); /* L */ + cio_seek(box.init_pos + box.length); + +} + +/* +* Read the MOOV box +* +* Movie Box +* +*/ +int mj2_read_moov(mj2_movie_t * movie, j2k_image_t * img) +{ + unsigned int i; + mj2_box_t box; + mj2_box_t box2; + + mj2_read_boxhdr(&box); + if (MJ2_MOOV != box.type) { + fprintf(stderr, "Error: Expected MOOV Marker\n"); + return 1; + } + + + + if (mj2_read_mvhd(movie)) + return 1; + + + movie->tk = + (mj2_tk_t *) malloc((movie->next_tk_id - 1) * sizeof(mj2_tk_t)); + + for (i = 0; cio_tell() - box.init_pos < box.length; i++) { + mj2_read_boxhdr(&box2); + if (box2.type == MJ2_TRAK) { + cio_seek(box2.init_pos); + if (mj2_read_trak(&movie->tk[i], img)) + return 1; + + if (movie->tk[i].track_type == 0) { + movie->num_vtk++; + } else if (movie->tk[i].track_type == 1) { + movie->num_stk++; + } else if (movie->tk[i].track_type == 2) { + movie->num_htk++; + } + } else if (box2.type == MJ2_MVEX) { + cio_seek(box2.init_pos); + cio_skip(box2.length); + i--; + } else { + fprintf(stderr, "Error with MOOV Box: Expected TRAK or MVEX box\n"); + return 1; + } + } + return 0; +} + +int mj2_read_struct(FILE *file, mj2_movie_t * movie) { + mj2_box_t box; + j2k_image_t img; + char * src; + int fsresult; + int foffset; + + movie->num_vtk=0; + movie->num_stk=0; + movie->num_htk=0; + + src = (char*) malloc (300 * sizeof(char)); + fread(src,300,1, file); // Assuming that jp and ftyp markers size do + // not exceed 300 bytes + + cio_init(src, 300); + + if (mj2_read_jp()) + return 1; + if (mj2_read_ftyp(movie)) + return 1; + + fsresult = fseek(file,cio_tell(),SEEK_SET); + if( fsresult ) { + fprintf(stderr, "End of file reached while trying to read data after FTYP box\n" ); + return 1; + } + + foffset = cio_tell(); + + box.type = 0; + + fread(src,30,1,file); + cio_init(src, 30); + mj2_read_boxhdr(&box); + + while(box.type != MJ2_MOOV) { + + switch(box.type) + { + case MJ2_MDAT: + fsresult = fseek(file,foffset+box.length,SEEK_SET); + if( fsresult ) { + fprintf(stderr, "End of file reached while trying to read MDAT box\n" ); + return 1; + } + foffset += box.length; + break; + + case MJ2_MOOF: + fsresult = fseek(file,foffset+box.length,SEEK_SET); + if( fsresult ) { + fprintf(stderr, "End of file reached while trying to read MOOF box\n" ); + return 1; + } + foffset += box.length; + break; + case MJ2_FREE: + fsresult = fseek(file,foffset+box.length,SEEK_SET); + if( fsresult ) { + fprintf(stderr, "End of file reached while trying to read FREE box\n" ); + return 1; + } + foffset += box.length; + break; + case MJ2_SKIP: + fsresult = fseek(file,foffset+box.length,SEEK_SET); + if( fsresult ) { + fprintf(stderr, "End of file reached while trying to read SKIP box\n" ); + return 1; + } + foffset += box.length; + break; + default: + fprintf(stderr, "Unknown box in MJ2 stream\n"); + fsresult = fseek(file,foffset+box.length,SEEK_SET); + if( fsresult ) { + fprintf(stderr, "End of file reached while trying to read end of unknown box\n"); + return 1; + } + foffset += box.length; + break; + } + fsresult = fread(src,8,1,file); + if (fsresult != 1) { + fprintf(stderr, "MOOV box not found in file\n"); + return 1; + } + cio_init(src, 8); + mj2_read_boxhdr(&box); + } + + fseek(file,foffset,SEEK_SET); + src = realloc(src,box.length); + fsresult = fread(src,box.length,1,file); + if (fsresult != 1) { + fprintf(stderr, "End of file reached while trying to read MOOV box\n"); + return 1; + } + + cio_init(src, box.length); + + if (mj2_read_moov(movie, &img)) + return 1; + + free(src); + return 0; +} diff --git a/mj2/MJ2_codec/mj2.h b/mj2/MJ2_codec/mj2.h new file mode 100644 index 00000000..0ba4897d --- /dev/null +++ b/mj2/MJ2_codec/mj2.h @@ -0,0 +1,201 @@ +/* +* Copyright (c) 2003-2004, François-Olivier Devaux +* Copyright (c) 2003-2004, Communications and remote sensing Laboratory, Universite catholique de Louvain, Belgium +* All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS' + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +#include +#include + +#ifndef __MJ2_H +#define __MJ2_H + +typedef struct { /* Time To Sample */ + int sample_count; + int sample_delta; +} mj2_tts_t; + +typedef struct { /* Chunk */ + int num_samples; + int sample_descr_idx; + int offset; +} mj2_chunk_t; + +typedef struct { /* Sample to chunk */ + int first_chunk; + int samples_per_chunk; + int sample_descr_idx; +} mj2_sampletochunk_t; + +typedef struct { /* Sample */ + unsigned int sample_size; + unsigned int offset; + unsigned int sample_delta; +} mj2_sample_t; + +typedef struct { /* URL */ + int location[4]; +} mj2_url_t; + +typedef struct { /* URN */ + int name[2]; + int location[4]; +} mj2_urn_t; + +typedef struct { /* Video Track Parameters */ + int track_ID; + int track_type; + unsigned int creation_time; + unsigned int modification_time; + int duration; + int timescale; + int layer; + int volume; + int language; + int balance; + int maxPDUsize; + int avgPDUsize; + int maxbitrate; + int avgbitrate; + int slidingavgbitrate; + int graphicsmode; + int opcolor[3]; + int num_url; + mj2_url_t *url; + int num_urn; + mj2_urn_t *urn; + int Dim[2]; + int w; + int h; + int visual_w; + int visual_h; + int CbCr_subsampling_dx; + int CbCr_subsampling_dy; + // int subsampling_dx; + // int subsampling_dy; + int sample_rate; + int sample_description; + int horizresolution; + int vertresolution; + int compressorname[8]; + int depth; + unsigned char fieldcount; + unsigned char fieldorder; + unsigned char or_fieldcount; + unsigned char or_fieldorder; + int num_br; + unsigned int *br; + unsigned char num_jp2x; + unsigned char *jp2xdata; + unsigned char hsub; + unsigned char vsub; + unsigned char hoff; + unsigned char voff; + int trans_matrix[9]; + unsigned int num_samples; /* Number of samples */ + int transorm; + int handler_type; + int name_size; + unsigned char same_sample_size; + int num_tts; + mj2_tts_t *tts; /* Time to sample */ + unsigned int num_chunks; + mj2_chunk_t *chunk; + int num_samplestochunk; + mj2_sampletochunk_t *sampletochunk; + char *name; + jp2_struct_t jp2_struct; + mj2_sample_t *sample; /* Sample parameters */ +} mj2_tk_t; /* Track Parameters */ + +typedef struct { /* Movie */ + unsigned int brand; + unsigned int minversion; + int num_cl; + unsigned int *cl; + unsigned int creation_time; + unsigned int modification_time; + int timescale; + unsigned int duration; + int rate; + int num_vtk; + int num_stk; + int num_htk; + int volume; + int trans_matrix[9]; + int next_tk_id; + mj2_tk_t *tk; /* Track Parameters */ +} mj2_movie_t; + +typedef struct { + int length; + int type; + int init_pos; +} mj2_box_t; + +void mj2_write_jp(); + +void mj2_write_ftyp(mj2_movie_t * movie); + +/* + * Use this function to initialize a standard movie with standard values + * It has one sample per chunk + */ +int mj2_init_stdmovie(mj2_movie_t * movie); + + +/* int mj2_encode(mj2_movie_t * movie, j2k_cp_t * cp, char *index); + * + * Encode a MJ2 movie from a yuv file + * movie: an existing mj2_movie structure (to create a standard one, use mj2_init_stdmovie + * cp: coding parameters of j2k images + * index: index file name + */ +int mj2_encode(mj2_movie_t * movie, j2k_cp_t * cp, char *index); + + +/* int mj2_decode(unsigned char *src, int len, mj2_movie_t * movie, + * j2k_cp_t * cp, char *outfile); + * + * Decode a MJ2 movie to a yuv file + * src: pointer to memory where frames will be stored + * movie: a mj2_movie structure + * cp: coding parameters of j2k images + * outfile: yuv file name + */ +int mj2_decode(unsigned char *src, int len, mj2_movie_t * movie, + j2k_cp_t * cp, char *outfile); + + +/* + * Free memory used to encode and decode mj2 files + * + */ +void mj2_memory_free(mj2_movie_t * movie); + +int mj2_read_struct(FILE *file, mj2_movie_t * movie); + +void mj2_write_moov(mj2_movie_t * movie); + +#endif diff --git a/mj2/MJ2_codec/mj2_convert.c b/mj2/MJ2_codec/mj2_convert.c new file mode 100644 index 00000000..dcce84ef --- /dev/null +++ b/mj2/MJ2_codec/mj2_convert.c @@ -0,0 +1,318 @@ +#include +#include + +#include "mj2.h" +#include +#include + +/* ----------------------- */ +/* */ +/* */ +/* Count the number of frames */ +/* in a YUV file */ +/* */ +/* ----------------------- */ + +int yuv_num_frames(mj2_tk_t * tk, FILE *f) +{ + int numimages, frame_size; + long end_of_f; + + frame_size = (int) (tk->w * tk->h * (1.0 + (double) 2 / (double) (tk->CbCr_subsampling_dx * tk->CbCr_subsampling_dy))); /* Calculate frame size */ + + fseek(f, 0, SEEK_END); + end_of_f = ftell(f); /* Calculate file size */ + + if (end_of_f < frame_size) { + fprintf(stderr, + "YUV does not contains any frame of %d x %d size\n", tk->w, + tk->h); + return 0; + } + + numimages = end_of_f / frame_size; /* Calculate number of images */ + + return numimages; + fclose(f); +} + +// ----------------------- +// +// +// YUV to IMAGE +// +// ----------------------- + +int yuvtoimage(FILE *yuvfile, mj2_tk_t * tk, j2k_image_t * img, + int frame_num, int subsampling_dx, int subsampling_dy) +{ + int i, j; + int offset; + long end_of_f, position; + FILE *Compo; + + offset = + (int) ((double) (frame_num * tk->w * tk->h) * + (1.0 + + 1.0 * (double) 2 / (double) (tk->CbCr_subsampling_dx * + tk->CbCr_subsampling_dy))); + fseek(yuvfile, 0, SEEK_END); + end_of_f = ftell(yuvfile); + fseek(yuvfile, sizeof(unsigned char) * offset, SEEK_SET); + position = ftell(yuvfile); + if (position >= end_of_f) { + fprintf(stderr, "Cannot reach frame number %d in yuv file !!\n", + frame_num); + return 0; + } + + img->x0 = tk->Dim[0]; + img->y0 = tk->Dim[1]; + img->x1 = !tk->Dim[0] ? (tk->w - 1) * subsampling_dx + 1 : tk->Dim[0] + + (tk->w - 1) * subsampling_dx + 1; + img->y1 = !tk->Dim[1] ? (tk->h - 1) * subsampling_dy + 1 : tk->Dim[1] + + (tk->h - 1) * subsampling_dy + 1; + img->numcomps = 3; + img->color_space = 3; + img->comps = (j2k_comp_t *) malloc(img->numcomps * sizeof(j2k_comp_t)); + + for (i = 0; i < img->numcomps; i++) { + img->comps[i].data = (int *) malloc(sizeof(int) * tk->w * tk->h); + img->comps[i].prec = 8; + img->comps[i].bpp = 8; + img->comps[i].sgnd = 0; + if (i == 0) { + img->comps[i].dx = subsampling_dx; + img->comps[i].dy = subsampling_dy; + } else { + img->comps[i].dx = subsampling_dx * tk->CbCr_subsampling_dx; + img->comps[i].dy = subsampling_dy * tk->CbCr_subsampling_dy; + } + } + + Compo = fopen("Compo0", "wb"); + if (!Compo) { + fprintf(stderr, "Failed to open Compo0 for writing !\n"); + } + + for (i = 0; i < (tk->w * tk->h / (img->comps[0].dx * img->comps[0].dy)) + && !feof(yuvfile); i++) { + unsigned char y; + j = fread(&y, 1, 1, yuvfile); + fwrite(&y, 1, 1, Compo); + } + + fclose(Compo); + + Compo = fopen("Compo1", "wb"); + if (!Compo) { + fprintf(stderr, "Failed to open Compo1 for writing !\n"); + } + + + for (i = 0; i < (tk->w * tk->h / (img->comps[1].dx * img->comps[1].dy)) + && !feof(yuvfile); i++) { + unsigned char cb; + j = fread(&cb, sizeof(unsigned char), 1, yuvfile); + fwrite(&cb, 1, 1, Compo); + } + + fclose(Compo); + + Compo = fopen("Compo2", "wb"); + if (!Compo) { + fprintf(stderr, "Failed to open Compo2 for writing !\n"); + } + + + for (i = 0; i < (tk->w * tk->h / (img->comps[2].dx * img->comps[2].dy)) + && !feof(yuvfile); i++) { + unsigned char cr; + j = fread(&cr, sizeof(unsigned char), 1, yuvfile); + fwrite(&cr, 1, 1, Compo); + } + + fclose(Compo); + return 1; +} + + + +// ----------------------- +// +// +// IMAGE to YUV +// +// ----------------------- + + +int imagetoyuv(j2k_image_t * img, j2k_cp_t * cp, char *outfile) +{ + FILE *f; + int i; + + if (img->numcomps == 3) { + if (img->comps[0].dx != img->comps[1].dx / 2 + || img->comps[1].dx != img->comps[2].dx) { + fprintf(stderr, + "Error with the input image components size: cannot create yuv file)\n"); + return 1; + } + } else if (!(img->numcomps == 1)) { + fprintf(stderr, + "Error with the number of image components(must be one or three)\n"); + return 1; + } + + f = fopen(outfile, "a+b"); + if (!f) { + fprintf(stderr, "failed to open %s for writing\n", outfile); + return 1; + } + + + for (i = 0; i < (img->comps[0].w * img->comps[0].h); i++) { + unsigned char y; + y = img->comps[0].data[i]; + fwrite(&y, 1, 1, f); + } + + + if (img->numcomps == 3) { + for (i = 0; i < (img->comps[1].w * img->comps[1].h); i++) { + unsigned char cb; + cb = img->comps[1].data[i]; + fwrite(&cb, 1, 1, f); + } + + + for (i = 0; i < (img->comps[2].w * img->comps[2].h); i++) { + unsigned char cr; + cr = img->comps[2].data[i]; + fwrite(&cr, 1, 1, f); + } + } else if (img->numcomps == 1) { + for (i = 0; i < (img->comps[0].w * img->comps[0].h * 0.25); i++) { + unsigned char cb = 125; + fwrite(&cb, 1, 1, f); + } + + + for (i = 0; i < (img->comps[0].w * img->comps[0].h * 0.25); i++) { + unsigned char cr = 125; + fwrite(&cr, 1, 1, f); + } + } + fclose(f); + return 0; +} + +// ----------------------- +// +// +// IMAGE to BMP +// +// ----------------------- + +int imagetobmp(j2k_image_t * img, j2k_cp_t * cp, char *outfile) { + int w,wr,h,hr,i,pad; + FILE *f; + + if (img->numcomps == 3 && img->comps[0].dx == img->comps[1].dx + && img->comps[1].dx == img->comps[2].dx + && img->comps[0].dy == img->comps[1].dy + && img->comps[1].dy == img->comps[2].dy + && img->comps[0].prec == img->comps[1].prec + && img->comps[1].prec == img->comps[2].prec) { + /* -->> -->> -->> -->> + + 24 bits color + + <<-- <<-- <<-- <<-- */ + + f = fopen(outfile, "wb"); + if (!f) { + fprintf(stderr, "failed to open %s for writing\n", outfile); + return 1; + } + + w = img->comps[0].w; + wr = int_ceildivpow2(img->comps[0].w, img->comps[0].factor); + + h = img->comps[0].h; + hr = int_ceildivpow2(img->comps[0].h, img->comps[0].factor); + + fprintf(f, "BM"); + + /* FILE HEADER */ + /* ------------- */ + fprintf(f, "%c%c%c%c", + (unsigned char) (hr * wr * 3 + 3 * hr * (wr % 2) + + 54) & 0xff, + (unsigned char) ((hr * wr * 3 + 3 * hr * (wr % 2) + 54) + >> 8) & 0xff, + (unsigned char) ((hr * wr * 3 + 3 * hr * (wr % 2) + 54) + >> 16) & 0xff, + (unsigned char) ((hr * wr * 3 + 3 * hr * (wr % 2) + 54) + >> 24) & 0xff); + fprintf(f, "%c%c%c%c", (0) & 0xff, ((0) >> 8) & 0xff, + ((0) >> 16) & 0xff, ((0) >> 24) & 0xff); + fprintf(f, "%c%c%c%c", (54) & 0xff, ((54) >> 8) & 0xff, + ((54) >> 16) & 0xff, ((54) >> 24) & 0xff); + + /* INFO HEADER */ + /* ------------- */ + fprintf(f, "%c%c%c%c", (40) & 0xff, ((40) >> 8) & 0xff, + ((40) >> 16) & 0xff, ((40) >> 24) & 0xff); + fprintf(f, "%c%c%c%c", (unsigned char) ((wr) & 0xff), + (unsigned char) ((wr) >> 8) & 0xff, + (unsigned char) ((wr) >> 16) & 0xff, + (unsigned char) ((wr) >> 24) & 0xff); + fprintf(f, "%c%c%c%c", (unsigned char) ((hr) & 0xff), + (unsigned char) ((hr) >> 8) & 0xff, + (unsigned char) ((hr) >> 16) & 0xff, + (unsigned char) ((hr) >> 24) & 0xff); + fprintf(f, "%c%c", (1) & 0xff, ((1) >> 8) & 0xff); + fprintf(f, "%c%c", (24) & 0xff, ((24) >> 8) & 0xff); + fprintf(f, "%c%c%c%c", (0) & 0xff, ((0) >> 8) & 0xff, + ((0) >> 16) & 0xff, ((0) >> 24) & 0xff); + fprintf(f, "%c%c%c%c", + (unsigned char) (3 * hr * wr + + 3 * hr * (wr % 2)) & 0xff, + (unsigned char) ((hr * wr * 3 + 3 * hr * (wr % 2)) >> + 8) & 0xff, + (unsigned char) ((hr * wr * 3 + 3 * hr * (wr % 2)) >> + 16) & 0xff, + (unsigned char) ((hr * wr * 3 + 3 * hr * (wr % 2)) >> + 24) & 0xff); + fprintf(f, "%c%c%c%c", (7834) & 0xff, ((7834) >> 8) & 0xff, + ((7834) >> 16) & 0xff, ((7834) >> 24) & 0xff); + fprintf(f, "%c%c%c%c", (7834) & 0xff, ((7834) >> 8) & 0xff, + ((7834) >> 16) & 0xff, ((7834) >> 24) & 0xff); + fprintf(f, "%c%c%c%c", (0) & 0xff, ((0) >> 8) & 0xff, + ((0) >> 16) & 0xff, ((0) >> 24) & 0xff); + fprintf(f, "%c%c%c%c", (0) & 0xff, ((0) >> 8) & 0xff, + ((0) >> 16) & 0xff, ((0) >> 24) & 0xff); + + for (i = 0; i < wr * hr; i++) { + unsigned char R, G, B; + /* a modifier */ + // R = img->comps[0].data[w * h - ((i) / (w) + 1) * w + (i) % (w)]; + R = img->comps[0].data[w * hr - ((i) / (wr) + 1) * w + (i) % (wr)]; + // G = img->comps[1].data[w * h - ((i) / (w) + 1) * w + (i) % (w)]; + G = img->comps[1].data[w * hr - ((i) / (wr) + 1) * w + (i) % (wr)]; + // B = img->comps[2].data[w * h - ((i) / (w) + 1) * w + (i) % (w)]; + B = img->comps[2].data[w * hr - ((i) / (wr) + 1) * w + (i) % (wr)]; + fprintf(f, "%c%c%c", B, G, R); + + if ((i + 1) % wr == 0) { + for (pad = (3 * wr) % 4 ? 4 - (3 * wr) % 4 : 0; pad > 0; pad--) /* ADD */ + fprintf(f, "%c", 0); + } + } + fclose(f); + free(img->comps[1].data); + free(img->comps[2].data); + } + return 0; +} diff --git a/mj2/MJ2_codec/mj2_convert.h b/mj2/MJ2_codec/mj2_convert.h new file mode 100644 index 00000000..e02bd430 --- /dev/null +++ b/mj2/MJ2_codec/mj2_convert.h @@ -0,0 +1,16 @@ +#include "mj2.h" + +#ifndef __MJ2_CONVERT_H +#define __MJ2_CONVERT_H + +int imagetoyuv(j2k_image_t * img, j2k_cp_t * cp, char *outfile); + +int imagetobmp(j2k_image_t * img, j2k_cp_t * cp, char *outfile); + +int yuvtoimage(FILE *yuvfile, mj2_tk_t * tk, j2k_image_t * img, + int frame_num, int subsampling_dx, int subsampling_dy); + +int yuv_num_frames(mj2_tk_t * tk, FILE *f); + + +#endif diff --git a/mj2/MJ2_codec/mj2_to_frames.c b/mj2/MJ2_codec/mj2_to_frames.c new file mode 100644 index 00000000..770ab529 --- /dev/null +++ b/mj2/MJ2_codec/mj2_to_frames.c @@ -0,0 +1,130 @@ +#include +#include +#include + +#include "mj2.h" +#include "mj2_convert.h" +#include + +//MEMORY LEAK +#ifdef _DEBUG +#define _CRTDBG_MAP_ALLOC +#include // Must be included first +#include +#endif +//MEM + +jmp_buf j2k_error; + +int main(int argc, char *argv[]) { + + unsigned int tnum, snum; + mj2_movie_t movie; + mj2_tk_t *track; + mj2_sample_t *sample; + unsigned char* frame_codestream; + FILE *file, *outfile; + char outfilename[50]; + j2k_image_t img; + j2k_cp_t cp; + int i; + + cp.layer=0; + cp.reduce=0; + + if (argc != 3) { + printf("Bad syntax: Usage: MJ2_decoder inputfile.mj2 outputfile.yuv\n"); + printf("Example: MJ2_decoder foreman.mj2 foreman.yuv\n"); + return 1; + } + + file = fopen(argv[1], "rb"); + + if (!file) { + fprintf(stderr, "failed to open %s for reading\n", argv[1]); + return 1; + } + + // Checking output file + outfile = fopen(argv[2], "w"); + if (!file) { + fprintf(stderr, "failed to open %s for writing\n", argv[2]); + return 1; + } + fclose(outfile); + + if (mj2_read_struct(file, &movie)) // Creating the movie structure + return 1; + + + // Decode first video track + tnum = 0; + while (movie.tk[tnum].track_type != 0) + tnum ++; + + track = &movie.tk[tnum]; + + // Output info on first video tracl + fprintf(stdout,"The first video track contains %d frames.\nWidth: %d, Height: %d \n\n", + track->num_samples, track->w, track->h); + + for (snum=0; snum < track->num_samples; snum++) + { + fprintf(stdout,"Frame %d: ",snum+1); + sample = &track->sample[snum]; + frame_codestream = (unsigned char*) malloc (sample->sample_size-8); // Skipping JP2C marker + fseek(file,sample->offset+8,SEEK_SET); + fread(frame_codestream,sample->sample_size-8,1, file); // Assuming that jp and ftyp markers size do + + if (!j2k_decode(frame_codestream, sample->sample_size-8, &img, &cp)) // Decode J2K to image + return 1; + + if (((img.numcomps == 3) && (img.comps[0].dx == img.comps[1].dx / 2) + && (img.comps[0].dx == img.comps[2].dx / 2 ) && (img.comps[0].dx == 1)) + || (img.numcomps == 1)) { + + if (imagetoyuv(&img, &cp, argv[2])) // Convert image to YUV + return 1; + } + else if ((img.numcomps == 3) && + (img.comps[0].dx == 1) && (img.comps[1].dx == 1)&& + (img.comps[2].dx == 1))// If YUV 4:4:4 input --> to bmp + { + fprintf(stdout,"The frames will be output in a bmp format (output_1.bmp, ...)\n"); + sprintf(outfilename,"output_%d.bmp",snum); + if (imagetobmp(&img, &cp, outfilename)) // Convert image to YUV + return 1; + + } + else { + fprintf(stdout,"Image component dimensions are unknown. Unable to output image\n"); + fprintf(stdout,"The frames will be output in a j2k file (output_1.j2k, ...)\n"); + + sprintf(outfilename,"output_%d.j2k",snum); + outfile = fopen(outfilename, "wb"); + if (!outfile) { + fprintf(stderr, "failed to open %s for writing\n",outfilename); + return 1; + } + fwrite(frame_codestream,sample->sample_size-8,1,outfile); + fclose(outfile); + } + for (i=0; i +# Microsoft Developer Studio Generated Build File, Format Version 6.00 +# ** DO NOT EDIT ** + +# TARGTYPE "Win32 (x86) Console Application" 0x0103 + +CFG=mj2_to_frames - Win32 Debug +!MESSAGE This is not a valid makefile. To build this project using NMAKE, +!MESSAGE use the Export Makefile command and run +!MESSAGE +!MESSAGE NMAKE /f "mj2_to_frames.mak". +!MESSAGE +!MESSAGE You can specify a configuration when running NMAKE +!MESSAGE by defining the macro CFG on the command line. For example: +!MESSAGE +!MESSAGE NMAKE /f "mj2_to_frames.mak" CFG="mj2_to_frames - Win32 Debug" +!MESSAGE +!MESSAGE Possible choices for configuration are: +!MESSAGE +!MESSAGE "mj2_to_frames - Win32 Release" (based on "Win32 (x86) Console Application") +!MESSAGE "mj2_to_frames - Win32 Debug" (based on "Win32 (x86) Console Application") +!MESSAGE + +# Begin Project +# PROP AllowPerConfigDependencies 0 +# PROP Scc_ProjName "" +# PROP Scc_LocalPath "" +CPP=cl.exe +RSC=rc.exe + +!IF "$(CFG)" == "mj2_to_frames - Win32 Release" + +# PROP BASE Use_MFC 0 +# PROP BASE Use_Debug_Libraries 0 +# PROP BASE Output_Dir "Release" +# PROP BASE Intermediate_Dir "Release" +# PROP BASE Target_Dir "" +# PROP Use_MFC 0 +# PROP Use_Debug_Libraries 0 +# PROP Output_Dir "Release" +# PROP Intermediate_Dir "Release" +# PROP Ignore_Export_Lib 0 +# PROP Target_Dir "" +# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c +# ADD CPP /nologo /W3 /GX /O2 /I "../libopenjpeg" /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c +# ADD BASE RSC /l 0x809 /d "NDEBUG" +# ADD RSC /l 0x809 /d "NDEBUG" +BSC32=bscmake.exe +# ADD BASE BSC32 /nologo +# ADD BSC32 /nologo +LINK32=link.exe +# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386 +# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386 + +!ELSEIF "$(CFG)" == "mj2_to_frames - Win32 Debug" + +# PROP BASE Use_MFC 0 +# PROP BASE Use_Debug_Libraries 1 +# PROP BASE Output_Dir "mj2_to_frames___Win32_Debug0" +# PROP BASE Intermediate_Dir "mj2_to_frames___Win32_Debug0" +# PROP BASE Target_Dir "" +# PROP Use_MFC 0 +# PROP Use_Debug_Libraries 1 +# PROP Output_Dir "mj2_to_frames___Win32_Debug0" +# PROP Intermediate_Dir "mj2_to_frames___Win32_Debug0" +# PROP Target_Dir "" +# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c +# ADD CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c +# ADD BASE RSC /l 0x809 /d "_DEBUG" +# ADD RSC /l 0x809 /d "_DEBUG" +BSC32=bscmake.exe +# ADD BASE BSC32 /nologo +# ADD BSC32 /nologo +LINK32=link.exe +# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept +# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept + +!ENDIF + +# Begin Target + +# Name "mj2_to_frames - Win32 Release" +# Name "mj2_to_frames - Win32 Debug" +# Begin Group "MJ2" + +# PROP Default_Filter "" +# Begin Group "MJ2 Header Files" + +# PROP Default_Filter "" +# Begin Source File + +SOURCE=.\compat\getopt.h +# End Source File +# Begin Source File + +SOURCE=.\mj2.h +# End Source File +# Begin Source File + +SOURCE=.\mj2_convert.h +# End Source File +# End Group +# Begin Group "MJ2 Source Files" + +# PROP Default_Filter "" +# Begin Source File + +SOURCE=.\compat\getopt.c + +!IF "$(CFG)" == "mj2_to_frames - Win32 Release" + +!ELSEIF "$(CFG)" == "mj2_to_frames - Win32 Debug" + +# ADD CPP /I "../libopenjpeg" + +!ENDIF + +# End Source File +# Begin Source File + +SOURCE=.\mj2.c + +!IF "$(CFG)" == "mj2_to_frames - Win32 Release" + +!ELSEIF "$(CFG)" == "mj2_to_frames - Win32 Debug" + +# ADD CPP /I "../libopenjpeg" + +!ENDIF + +# End Source File +# Begin Source File + +SOURCE=.\mj2_convert.c + +!IF "$(CFG)" == "mj2_to_frames - Win32 Release" + +!ELSEIF "$(CFG)" == "mj2_to_frames - Win32 Debug" + +# ADD CPP /I "../libopenjpeg" + +!ENDIF + +# End Source File +# Begin Source File + +SOURCE=.\mj2_to_frames.c + +!IF "$(CFG)" == "mj2_to_frames - Win32 Release" + +!ELSEIF "$(CFG)" == "mj2_to_frames - Win32 Debug" + +# ADD CPP /I "../libopenjpeg" + +!ENDIF + +# End Source File +# End Group +# End Group +# Begin Group "OpenJPEG" + +# PROP Default_Filter "" +# Begin Group "OpenJPEG Header Files" + +# PROP Default_Filter ".h" +# Begin Source File + +SOURCE=..\libopenjpeg\bio.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\cio.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\dwt.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\fix.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\int.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\j2k.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\jp2.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\jpt.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\mct.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\mqc.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\openjpeg.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\pi.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\raw.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\t1.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\t2.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\tcd.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\tgt.h +# End Source File +# End Group +# Begin Group "OpenJPEG Source Files" + +# PROP Default_Filter ".c" +# Begin Source File + +SOURCE=..\libopenjpeg\bio.c +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\cio.c +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\dwt.c +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\fix.c +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\int.c +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\j2k.c +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\jp2.c +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\jpt.c +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\mct.c +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\mqc.c +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\pi.c +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\raw.c +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\t1.c +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\t2.c +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\tcd.c +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\tgt.c +# End Source File +# End Group +# End Group +# End Target +# End Project diff --git a/mj2/MJ2_codec/mj2_to_metadata.c b/mj2/MJ2_codec/mj2_to_metadata.c new file mode 100644 index 00000000..45a91b1c --- /dev/null +++ b/mj2/MJ2_codec/mj2_to_metadata.c @@ -0,0 +1,281 @@ +/* mj2_to_metadata.c */ +/* Dump MJ2, JP2 metadata (partial so far) to xml file */ +/* Contributed to Open JPEG by Glenn Pearson, contract software developer, U.S. National Library of Medicine. + +The base code in this file was developed by the author as part of a video archiving +project for the U.S. National Library of Medicine, Bethesda, MD. +It is the policy of NLM (and U.S. government) to not assert copyright. + +A non-exclusive copy of this code has been contributed to the Open JPEG project. +Except for copyright, inclusion of the code within Open JPEG for distribution and use +can be bound by the Open JPEG open-source license and disclaimer, expressed elsewhere. +*/ +#include +#include +#include + +#include "mj2.h" +#include + +//MEMORY LEAK +#ifdef _DEBUG +#define _CRTDBG_MAP_ALLOC +#include // Must be included first +#include +#endif +//MEM + +#include "mj2_to_metadata.h" +#include +#ifndef DONT_HAVE_GETOPT +#include +#else +#include "compat/getopt.h" +#endif + +/* ------------- */ + +void help_display() +{ + /* "1234567890123456789012345678901234567890123456789012345678901234567890123456789" */ + fprintf(stdout," Help for the 'mj2_to_metadata' Program\n"); + fprintf(stdout," ======================================\n"); + fprintf(stdout,"The -h option displays this information on screen.\n\n"); + + fprintf(stdout,"mj2_to_metadata generates an XML file from a Motion JPEG 2000 file.\n"); + fprintf(stdout,"The generated XML shows the structural, but not (yet) curatorial,\n"); + fprintf(stdout,"metadata from the movie header and from the JPEG 2000 image and tile\n"); + fprintf(stdout,"headers of a sample frame. Excluded: low-level packed-bits image data.\n\n"); + + fprintf(stdout,"By Default\n"); + fprintf(stdout,"----------\n"); + fprintf(stdout,"The metadata includes the jp2 image and tile headers of the first frame.\n"); + fprintf(stdout,"\n"); + fprintf(stdout,"Metadata values are shown in 'raw' form (e.g., hexidecimal) as stored in the\n"); + fprintf(stdout,"file, and, if apt, in a 'derived' form that is more quickly grasped.\n"); + fprintf(stdout,"\n"); + fprintf(stdout,"Notes explaining the XML are embedded as terse comments. These include\n"); + fprintf(stdout," meaning of non-obvious tag abbreviations;\n"); + fprintf(stdout," range and precision of valid values;\n"); + fprintf(stdout," interpretations of values, such as enumerations; and\n"); + fprintf(stdout," current implementation limitations.\n"); + fprintf(stdout,"\n"); + fprintf(stdout,"The sample-size and chunk-offset tables, each with 1 row per frame, are not reported.\n"); + fprintf(stdout,"\n"); + fprintf(stdout,"The file is self-contained and no verification (e.g., against a DTD) is requested.\n"); + fprintf(stdout,"\n"); + fprintf(stdout,"Required Parameters (except with -h)\n"); + fprintf(stdout,"------------------------------------\n"); + fprintf(stdout,"[Caution: file strings that contain spaces should be wrapped with quotes.]\n"); + fprintf(stdout,"-i input.mj2 : where 'input' is any source file name or path.\n"); + fprintf(stdout," MJ2 files created with 'frames_to_mj2' are supported so far.\n"); + fprintf(stdout," These are silent, single-track, 'MJ2 Simple Profile' videos.\n"); + fprintf(stdout,"-o output.xml : where 'output' is any destination file name or path.\n"); + fprintf(stdout,"\n"); + fprintf(stdout,"Optional Parameters\n"); + fprintf(stdout,"-------------------\n"); + fprintf(stdout,"-h : Display this help information.\n"); + fprintf(stdout,"-n : Suppress all mj2_to_metadata notes.\n"); + fprintf(stdout,"-t : Include sample-size and chunk-offset tables.\n"); + fprintf(stdout,"-f n : where n > 0. Include jp2 header info for frame n [default=1].\n"); + fprintf(stdout,"-f 0 : No jp2 header info.\n"); + fprintf(stdout,"-r : Suppress all 'raw' data for which a 'derived' form exists.\n"); + fprintf(stdout,"-d : Suppress all 'derived' data.\n"); + fprintf(stdout," (If both -r and -d given, -r will be ignored.)\n"); + fprintf(stdout,"-v string : Verify against the DTD file located by the string.\n"); + fprintf(stdout," Prepend quoted 'string' with either SYSTEM or PUBLIC keyword.\n"); + fprintf(stdout," Thus, for the distributed DTD placed in the same directory as\n"); + fprintf(stdout," the output file: -v \"SYSTEM mj2_to_metadata.dtd\"\n"); + fprintf(stdout," \"PUBLIC\" is used with an access protocol (e.g., http:) + URL.\n"); + /* More to come */ + fprintf(stdout,"\n"); + /* "1234567890123456789012345678901234567890123456789012345678901234567890123456789" */ +} + +/* ------------- */ + +int main(int argc, char *argv[]) { + + FILE *file, *xmlout; +/* char xmloutname[50]; */ + mj2_movie_t movie; + + char* infile = 0; + char* outfile = 0; + char* s, S1, S2, S3; + int len; + unsigned int sampleframe = 1; /* First frame */ + char* stringDTD = NULL; + BOOL notes = TRUE; + BOOL sampletables = FALSE; + BOOL raw = TRUE; + BOOL derived = TRUE; + +#ifndef NO_PACKETS_DECODING + fprintf(stdout,"WARNING: For best performance, define NO_PACKETS_DECODING in preprocessing.\n"); +#endif + + while (TRUE) { + /* ':' after letter means it takes an argument */ + int c = getopt(argc, argv, "i:o:f:v:hntrd"); + /* FUTURE: Reserve 'p' for pruning file (which will probably make -t redundant) */ + if (c == -1) + break; + switch (c) { + case 'i': /* IN file */ + infile = optarg; + s = optarg; + while (*s) { s++; } /* Run to filename end */ + s--; + S3 = *s; + s--; + S2 = *s; + s--; + S1 = *s; + + if ((S1 == 'm' && S2 == 'j' && S3 == '2') + || (S1 == 'M' && S2 == 'J' && S3 == '2')) { + break; + } + fprintf(stderr, "Input file name must have .mj2 extension, not .%c%c%c.\n", S1, S2, S3); + return 1; + + /* ----------------------------------------------------- */ + case 'o': /* OUT file */ + outfile = optarg; + while (*outfile) { outfile++; } /* Run to filename end */ + outfile--; + S3 = *outfile; + outfile--; + S2 = *outfile; + outfile--; + S1 = *outfile; + + outfile = optarg; + + if ((S1 == 'x' && S2 == 'm' && S3 == 'l') + || (S1 == 'X' && S2 == 'M' && S3 == 'L')) + break; + + fprintf(stderr, + "Output file name must have .xml extension, not .%c%c%c\n", S1, S2, S3); + return 1; + + /* ----------------------------------------------------- */ + case 'f': /* Choose sample frame. 0 = none */ + sscanf(optarg, "%u", &sampleframe); + break; + + /* ----------------------------------------------------- */ + case 'v': /* Verification by DTD. */ + stringDTD = optarg; + /* We will not insist upon last 3 chars being "dtd", since non-file + access protocol may be used. */ + if(strchr(stringDTD,'"') != NULL) { + fprintf(stderr, "-D's string must not contain any embedded double-quote characters.\n"); + return 1; + } + + if (strncmp(stringDTD,"PUBLIC ",7) == 0 || strncmp(stringDTD,"SYSTEM ",7) == 0) + break; + + fprintf(stderr, "-D's string must start with \"PUBLIC \" or \"SYSTEM \"\n"); + return 1; + + /* ----------------------------------------------------- */ + case 'n': /* Suppress comments */ + notes = FALSE; + break; + + /* ----------------------------------------------------- */ + case 't': /* Show sample size and chunk offset tables */ + sampletables = TRUE; + break; + + /* ----------------------------------------------------- */ + case 'h': /* Display an help description */ + help_display(); + return 0; + + /* ----------------------------------------------------- */ + case 'r': /* Suppress raw data */ + raw = FALSE; + break; + + /* ----------------------------------------------------- */ + case 'd': /* Suppress derived data */ + derived = FALSE; + break; + + /* ----------------------------------------------------- */ + default: + return 1; + } /* switch */ + } /* while */ + + if(!raw && !derived) + raw = TRUE; /* At least one of 'raw' and 'derived' must be true */ + + /* Error messages */ + /* -------------- */ + if (!infile || !outfile) { + fprintf(stderr,"Correct usage: mj2_to_metadata -i mj2-file -o xml-file (plus options)\n"); + return 1; + } + +/* was: + if (argc != 3) { + printf("Bad syntax: Usage: MJ2_to_metadata inputfile.mj2 outputfile.xml\n"); + printf("Example: MJ2_to_metadata foreman.mj2 foreman.xml\n"); + return 1; + } +*/ + len = strlen(infile); + if(infile[0] == ' ') + { + infile++; /* There may be a leading blank if user put space after -i */ + } + + file = fopen(infile, "rb"); /* was: argv[1] */ + + if (!file) { + fprintf(stderr, "Failed to open %s for reading.\n", infile); /* was: argv[1] */ + return 1; + } + + len = strlen(outfile); + if(outfile[0] == ' ') + { + outfile++; /* There may be a leading blank if user put space after -o */ + } + + // Checking output file + xmlout = fopen(outfile, "w"); /* was: argv[2] */ + if (!xmlout) { + fprintf(stderr, "Failed to open %s for writing.\n", outfile); /* was: argv[2] */ + return 1; + } + // Leave it open + + if (mj2_read_struct(file, &movie)) // Creating the movie structure + { + fclose(xmlout); + return 1; + } + + xml_write_init(notes, sampletables, raw, derived); + xml_write_struct(file, xmlout, &movie, sampleframe, stringDTD); + fclose(xmlout); + + mj2_memory_free(&movie); + + //MEMORY LEAK + #ifdef _DEBUG + _CrtDumpMemoryLeaks(); + #endif + //MEM + + return 0; +} + + diff --git a/mj2/MJ2_codec/mj2_to_metadata.dsp b/mj2/MJ2_codec/mj2_to_metadata.dsp new file mode 100644 index 00000000..065904e2 --- /dev/null +++ b/mj2/MJ2_codec/mj2_to_metadata.dsp @@ -0,0 +1,276 @@ +# Microsoft Developer Studio Project File - Name="mj2_to_metadata" - Package Owner=<4> +# Microsoft Developer Studio Generated Build File, Format Version 6.00 +# ** DO NOT EDIT ** + +# TARGTYPE "Win32 (x86) Console Application" 0x0103 + +CFG=mj2_to_metadata - Win32 Debug +!MESSAGE This is not a valid makefile. To build this project using NMAKE, +!MESSAGE use the Export Makefile command and run +!MESSAGE +!MESSAGE NMAKE /f "mj2_to_metadata.mak". +!MESSAGE +!MESSAGE You can specify a configuration when running NMAKE +!MESSAGE by defining the macro CFG on the command line. For example: +!MESSAGE +!MESSAGE NMAKE /f "mj2_to_metadata.mak" CFG="mj2_to_metadata - Win32 Debug" +!MESSAGE +!MESSAGE Possible choices for configuration are: +!MESSAGE +!MESSAGE "mj2_to_metadata - Win32 Release" (based on "Win32 (x86) Console Application") +!MESSAGE "mj2_to_metadata - Win32 Debug" (based on "Win32 (x86) Console Application") +!MESSAGE + +# Begin Project +# PROP AllowPerConfigDependencies 0 +# PROP Scc_ProjName "" +# PROP Scc_LocalPath "" +CPP=cl.exe +RSC=rc.exe + +!IF "$(CFG)" == "mj2_to_metadata - Win32 Release" + +# PROP BASE Use_MFC 0 +# PROP BASE Use_Debug_Libraries 0 +# PROP BASE Output_Dir "Release" +# PROP BASE Intermediate_Dir "Release" +# PROP BASE Target_Dir "" +# PROP Use_MFC 0 +# PROP Use_Debug_Libraries 0 +# PROP Output_Dir "Release" +# PROP Intermediate_Dir "Release" +# PROP Target_Dir "" +# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c +# ADD CPP /nologo /W3 /GX /O2 /I "../libopenjpeg" /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /D "DONT_HAVE_GETOPT" /YX /FD /c +# ADD BASE RSC /l 0x809 /d "NDEBUG" +# ADD RSC /l 0x809 /d "NDEBUG" +BSC32=bscmake.exe +# ADD BASE BSC32 /nologo +# ADD BSC32 /nologo +LINK32=link.exe +# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386 +# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386 + +!ELSEIF "$(CFG)" == "mj2_to_metadata - Win32 Debug" + +# PROP BASE Use_MFC 0 +# PROP BASE Use_Debug_Libraries 1 +# PROP BASE Output_Dir "mj2_to_metadata___Win32_Debug0" +# PROP BASE Intermediate_Dir "mj2_to_metadata___Win32_Debug0" +# PROP BASE Target_Dir "" +# PROP Use_MFC 0 +# PROP Use_Debug_Libraries 1 +# PROP Output_Dir "mj2_to_metadata___Win32_Debug0" +# PROP Intermediate_Dir "mj2_to_metadata___Win32_Debug0" +# PROP Target_Dir "" +# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c +# ADD CPP /nologo /W3 /Gm /GX /ZI /Od /I "../libopenjpeg" /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /D "DONT_HAVE_GETOPT" /FR /YX /FD /GZ /c +# ADD BASE RSC /l 0x809 /d "_DEBUG" +# ADD RSC /l 0x809 /d "_DEBUG" +BSC32=bscmake.exe +# ADD BASE BSC32 /nologo +# ADD BSC32 /nologo +LINK32=link.exe +# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept +# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept + +!ENDIF + +# Begin Target + +# Name "mj2_to_metadata - Win32 Release" +# Name "mj2_to_metadata - Win32 Debug" +# Begin Group "MJ2" + +# PROP Default_Filter "" +# Begin Group "MJ2 Header Files" + +# PROP Default_Filter "" +# Begin Source File + +SOURCE=.\compat\getopt.h +# End Source File +# Begin Source File + +SOURCE=.\meta_out.h +# End Source File +# Begin Source File + +SOURCE=.\mj2.h +# End Source File +# Begin Source File + +SOURCE=.\mj2_convert.h +# End Source File +# End Group +# Begin Group "MJ2 Source Files" + +# PROP Default_Filter "" +# Begin Source File + +SOURCE=.\compat\getopt.c +# End Source File +# Begin Source File + +SOURCE=.\meta_out.c +# End Source File +# Begin Source File + +SOURCE=.\mj2.c +# End Source File +# Begin Source File + +SOURCE=.\mj2_convert.c +# End Source File +# Begin Source File + +SOURCE=.\mj2_to_metadata.c +# End Source File +# End Group +# End Group +# Begin Group "OpenJPEG" + +# PROP Default_Filter "" +# Begin Group "OpenJPEG Header Files" + +# PROP Default_Filter ".h" +# Begin Source File + +SOURCE=..\libopenjpeg\bio.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\cio.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\dwt.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\fix.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\int.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\j2k.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\jp2.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\jpt.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\mct.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\mqc.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\openjpeg.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\pi.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\raw.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\t1.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\t2.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\tcd.h +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\tgt.h +# End Source File +# End Group +# Begin Group "OpenJPEG Source Files" + +# PROP Default_Filter ".c" +# Begin Source File + +SOURCE=..\libopenjpeg\bio.c +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\cio.c +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\dwt.c +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\fix.c +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\int.c +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\j2k.c +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\jp2.c +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\jpt.c +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\mct.c +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\mqc.c +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\pi.c +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\raw.c +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\t1.c +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\t2.c +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\tcd.c +# End Source File +# Begin Source File + +SOURCE=..\libopenjpeg\tgt.c +# End Source File +# End Group +# End Group +# End Target +# End Project diff --git a/mj2/MJ2_codec/mj2_to_metadata.dtd b/mj2/MJ2_codec/mj2_to_metadata.dtd new file mode 100644 index 00000000..249de1a0 --- /dev/null +++ b/mj2/MJ2_codec/mj2_to_metadata.dtd @@ -0,0 +1,425 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/mj2/MJ2_codec/mj2_to_metadata.h b/mj2/MJ2_codec/mj2_to_metadata.h new file mode 100644 index 00000000..f4c34919 --- /dev/null +++ b/mj2/MJ2_codec/mj2_to_metadata.h @@ -0,0 +1,9 @@ +/* mj2_to_metadata.h */ +/* Dump MJ2, JP2 metadata (partial so far) to xml file */ +/* Contributed to Open JPEG by Glenn Pearson, U.S. National Library of Medicine */ + +#define BOOL int +#define FALSE 0 +#define TRUE 1 + +#include "meta_out.h" diff --git a/mj2/MJ2_codec/mj2_to_metadata.vcproj b/mj2/MJ2_codec/mj2_to_metadata.vcproj new file mode 100644 index 00000000..a35f07d0 --- /dev/null +++ b/mj2/MJ2_codec/mj2_to_metadata.vcproj @@ -0,0 +1,324 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/mj2/MJ2_codec/mj2_to_metadata_Notes.doc b/mj2/MJ2_codec/mj2_to_metadata_Notes.doc new file mode 100644 index 0000000000000000000000000000000000000000..05ccec2068dd5bff73cf83aab716406f6c1db099 GIT binary patch literal 35328 zcmeHQdz2hSxv!ahWy4N(6OzpmK{_FXU9!7ug5fD)L*8+d4M~9D;gZbG^k$pPbPwG# zo82VpAY92Gf>A&~;22Z{g$wcO(RimguuE>oZ9yvTC;UIdHy}w^|S8vZ` zX0s0uh)yNHsjk;oRbPGe)mPOuvrqnJ;((2(AFzB|hl41JH`ohUVtU{$NDvt_xqg*{Aw@+|W@_o|(3zG8bXP}Du~+wUjmJmN{85K8X0Vs>1P z^as$6pq#39ZwEixkWTrd`vvm74*x#L0o}7Ge?5GL8KvrH8l93~<*WV`^W9Q|pQ;`e zqsp-!$|3v7_MLi+5NMh|{v8N&{`A0a@OzDjB2Muu-&gXeeAN&7->MSg)p0^R9H8Hg zaitsv^RY_iqYH~rAh#P=`Ydsv#DO3O*60a6>gd`kE3G@)SG60GSIpgzwl*a7bTl4K zM{kU5G15JTsik{#tuv*Y+KSbSmujnR>k2)V)_PmDw$`)HtX>(lV?Em3dCl6~wzhfI zT4ZTLH%)D|9oB_PsNJtw-P%e$Zo~{zZ;C88wV0Ji zM7u0o=F?caw#1H_uULlD(wQ)N4c*oj>AlfRpVqi;amV7*E?U^p6p5_uH?5RoIFT7E zb9*qOS<9Gl6pHJ;dcsO2bu-4Jq-CcKbCc$z?My74vB5{xwq~s> zlSU_dPfnJ7cktSGPVQJ04?3<$Z=)jueWr#RY-ZabRP9Vxk2%$+efh>cx(ESiCU=l2J3 zj+99U1vQGg&r~^VaV-VeC9jo0FuNzmHblt=QI*uJ&G6{E?SRb1E!}AXyVvL#D?>^Y z31BFUWXfXYU=cXIa>ZQjhP8+TFEFbpLN{ubndsLV9X-+ALa~TKF2O`fmz1G7kT)lT zu}|C4*yd&ptx8%>TAQOe7G&LxZi=k3+;C(L%IXR92tyzns5P3F*C>K zeQrw^1kUR2cJ#EPHL^Cx*s6PzXYSGqFv%A8r7-K!mQFePk#!IrR}iF>Z!r=H2$O8E zreoyIv=L39EBKJSW@mdaqtFh+?6&NrI|U?P!5N25L5j?)_Zg0qbqiYOij=-7e~>Ui z%vd55=NM6nd#yw!X_!_96S^m3ZkF+sF|fQFbLYwohC)t(1qsJ$maO#Z%4H`ShB+Rb zrkG3~-&j$%VT0Kj6O&fZ8Jl$oWtXl|Ky5z9^=`w24(rvywpECZgyEM zKhz~$aL9E@w+mFTM(N2eJlW5Y= ztcw?(c|_W(j+InRP`dqA2BXjqkw(KfGSMz0VWj)fdI!_RU345PA^EZnZ3Zi(z2MDq zsx+)+Qa6!TvbhigUpl24Q5{gNzYNOqoJgKVZtZE-T4NC|XB(hXR4{ijZ;d-!kgYey z{vSaho{nQ}>4sL5vPm|^)iP@9T;+5r(Ht&xpjS5yN*FR@a!FQTdXQ-`E7hOBVzh!f z`N5HsYlf5QibHy0X$x|Jq08@&-luD=QWn)AntX^?Yz--|Bf^cJbI+!8F zY=;pW4j|^}YVJep^+pZYehIFN1uT#r%rD!}yQ$BDb_RG#yMd!~PDJ%g*W|qLR60i(c8%5pQV%qPX1@$;;8$f~DA9NFY-f%emgd1Hps7 zio$U2->OrnG2~F5jV;}pd9G$^=V@)Q_o9%c8%&swl!Y75rHn;0iL^|g(-gt_4_i`0 z%dk#?1LTcdX|S9{rD_AgUTy8AYu7DaxxunGtiI@ij^ztCaD^~8HMK^RQUzfw2?_L! zeByNSW(BR7yv4T}+`>XnGr-wwq*5r<*pddZNGA%}IU@;5&?dUc^~yIIQ;;{go&;BT z&-|pWhoYtClxkI~PmB$16n0MQ*0%(VbBv8cwzx; zKLs8IehEAVJPzyw_5*(a-UXIc3$YSdjMF0rNCUmV7l6aB{C5AN5B^~Py$^o<=C540 z8N>62$Z9ba(H4nm%`mO)6wH8J@o5)9;*I{m*ZFSyS=BuIOcK7Up-0i$uH-n zOjUHe@WK_xizqO$zGvLxyI3L+A_51aSN^0LSiHAdAz!tAOW$mw;*A*~&4VVMW16BiT zfIl66>+r$14!-!i!v~)}xbNUEe)hfZ+;!(&hwpmp@LhM@deh;X?zri#Tfcnkb>G?X zoolXhgf^w;vQ=+FUmgzCiiIocMdymJxDdD;h$76jggLlsc={hP%*_;PQ~K2D^k1oe zUHWoLA$(o(_cAP}6xIlqb4x=vPje|QTrnB7mZ8=%)LMpG@e&AS<+Mf~PT694xGHeX z%2^%!)lRL6a?<;;G6ec+g_OBKgTB8qiWcf;HFg|_F9W-P2Z4P6$Ax2}#)IR~32+=f z1AG>^1-KQsA9w)R2b^-O5DS1T@NRHIy;C&sS}kNz5F~w z+KV?YUnXanoZFZU%1(5(ft=5nF>Xlanc&Xy2|*wt@RXQ71Bb5f(B#Nh7G&8I9CssBKMK2pT= zSz^x4p3pg|&FS;SiMyXXP1}9oyy?4lRm=cR+PSM@CUElZe-hT0x^V;tCW~4z3C6+g z@XP$vb}ZU|90-ecd85gVt`w_;C2WxtQISAY7-+!a(jYc03zbLVCzn-Y(X1{{18$k% z=OVG7{q2D}#UfEdy(L{eLb~V%#SCbsg(g{TG zl^U@QCAvUCNABEK9xtZ8i++9LnMx5FUzTtmDi9N8bXZ_pgWFV_+us>@h_|ZzmQ_hQ zn&=RQaAe)=uX4QUh^_T3hI!eOKJP@W2fhS620RYz2kKF9DzFGx3}k>_;94MyHe3Zf z54;4BZ!JJ8FdulT5~nD@Dpb}9Tm)=`68|!=3wRJvCvH)gcN%tW(}6iaC$Jj$4Deat z7T{KZ_t72z_5r7$`wIZ>@@@p)0JzKB25blR0uKQd=x-%Z3p4?z0xiHT=%2h4MnCI; z&u|}XT6T!~hDsZ%okNuyMH zm-WDB*$0+`z`DUexuNkm3@s6LFgEk4aqk$FUZhL241<%Ma5=9ns1Y>pME&mV^ZX+yQsFNaJ8 zW%utqwtia*)Hm937;PWCa%@tubycmMT=VkRI<9k<&kwaJzHuapXT!IPL)-4Cx(sPZ zl`fc8v)xV0FX!gWhFC7_m7@fB5`rf;tysBWTk^_P1=Cbp-1jT>&y3%1?>sj@WuUfB+`X!A=FeZ)yP#0oj~7jB6c_l=9sD3tb`^P@GBKP_G?l(uf$6S2bOTsfZV={feZhoTNQr2%>e=kF7* zx#j&Sk5-7#li|wC<(d2~?{}^U;YCnLSdHS^9%kOLjD&u4h-IhlWQ^++vEwAMT@^mD zT@@gU@F+>Ok;7-59#M`&ggY?qfl0_pxK>YPQ}dmaPY| zZ2cI!y81Yu;OgT*aP@IRc9oJg)swfNcdV4T10kQ-fe`r?a*5$^VFkXN2wV<8?n0u) zm9}h%81Y&z9jiIYMr})HnP64r< zQ^wfUjSW7*jSV2UvEk@lE$QD{=v$v}CH*^sRrSNxzfvs)1h~)DnVtc$e$aqePXl5- zUh0p)fKbF-wbW4Qi%3Hyh&5CWZ>|O`5=GF}zy}8nh=VjB4vx%#$R)OCP=NQ)fY>uK z140pVySii0fY?C;V#ml02u0BC>iUU3@77NQ!Sxf5u9k}Ot#PtXtZ_1kHBKJGsJ=I7 zK)go-;=Pd@5V>7_Y|wysj0VJG!!RHU2(W8F6cga$21Eg_mBhCszEF$qHtEP+&6vcO z`WJU0J*_+Fl{Ih!H*V0z97h{-oU}1v@8W<$G|6J+*&_>&mxZ6L_NV!?)hPUIHK+OD zmJh#CAX+7j@aK!sxTj{~H5~(T2YF8oXxvk?5#b<>utx(2hl8#6p4@iy4O)+Vv>yAU z^%$g4=FuqLmt})S<1!kJ%cRj5q)~pZpC$af08M9VdXsjuZ0xG7dE8f~NyYQb(&B3#i$# z>Ba&CN58ZeB{rI+y#TSXE$syej(%w`N^CSsdjVo@S4X?F7a-_%b%aYhk12WBCgs@s z;6Yh1%tO3jm|9xwGIK6t}acKF+fLfr?Gmga3Q=EkJVxM>kpu-ZA5iw1M_AEHGP9HG$VLVFy=Z_)Mq#uo6AqkxB8jOgo2&D^nHT zkeFgKV2LgGWUN=36ueyY`JTYNRTF&X`-G+SJ3%TOt}Lr4uLzfwU%ORkh|VfHvLZyR z!@Zp(?gQcOKW_5qs87S4Axqv~;#-_~pc57q6`^pbsxn-mq)Ig&IYgEpYehfGbfIJd zq0?u{+K;I$57QN`eF1JS8Mu?gGUv~eWva@m!{Lf>dC@WpQAb9W)A6ZVEyTH%vZZWH z&>hjzOHiYUdsA`GcaVDqgyqU{I~v5HCt&<8featU4f^UM3C&t479>8#V`aRqU$xf%t*A>Z-Y)$Srg-W(zSEM~l>T zk<+ifkmICgg^JJhm&st$p@CYw$Hb2}z6i|%<@>o}ph6iKkndPgvKI46mv`=>m}Tnb zUD}&-$7*g}5xh6$y*v~Dc)L%R_xl{kx{0^2#nar7Ds8Ci7+jOcK95<4)~l3>*4dw zejGmE;3wcy_oU(TYWjBgte72TB|$aiGM35(i2gC~=^~ff5Hw94K+1 z#DURpV5t3n_~|E}zPIz%zm` z0z5ao5#T=hc7S{IZvouD-v{8QS8yKY?)Q0aK-$j&!F@f?6!24Qa{o(u+y}EB`aCnE z-#Kl(tOJil{g0z^wwrCpKPRX`B4YvRvqZ_2I8fq1i324LlsHi0K#2n- z4wN`h;y{T5B@UE0@X_V~cemX4au3aYHuv$||MGo3-_`RyJ>Si9|IWQR-^=qII`{qD zM{}Rgclg}T^Y4J-%k^?k&wV;Crt!ksG~i>v@xTcH_t+-_8ZaH00h|QP1WpEK0jB`G z??IZpJvbX^23mkt;548OVESD6rvsk=<^g8_X98ydO#d5juJ_C^QF1N^cqh)1zr3{= zH*(UrdDah34d2z{_K4yoWvH^6(j>%Q`H7$I3b?xPLHU;v&qG|+i=Pwt?XE!9VLwg~ zVOc-rmhBi$LEg=HioykV33_ki&fFsSG2Fl7ok8_mV{VS2Kc}I7&LPEvp>q$W^6#e7 zRp5ppYvr%1k@w3{d$(*8W74?G$D2~c9lnPkZ|`vK4!8eJB*)1MS8+toN7kORJpPZQ z|8rQeSAR(G-eVGHh@H4)c?DBOTe^xN^nu<4TH1!v!Hu99Q)KA$h>BArg z|Fxb&82vIV@a%QI?&kWPcZY3}70d8XOi7zyCUM=r~y z5+5uFKFIYyd*{AyT#5UQ3(>_ajRm;U`aiPu*5%sZ=UCT&>i>_r{XZIweF6H-eSz8! z&|iSK(a`!Rmr?6Kr{i$MOto<*qN z!LA^IT~I&1!4*YqI`XrKsBq^y(QN@2M)%DZO{ zyl=1xbc5eRY4>~5ioKSB_O>FA1s=F%cxI9N&6Q@*4Ssi}5iMK}?wtm|L#%|~fzU#H zKl~rveHi;cj^T^^fGh3)Tt1BDGdQD1O6SA2|BKx}qIl%rKcfDr$h(vD$cL2ETU-3a6;+xP?NAlP5sh8W}^Q?^Dsbcv50TTQuj{pDw literal 0 HcmV?d00001 diff --git a/mj2/MJ2_codec/readme.txt b/mj2/MJ2_codec/readme.txt new file mode 100644 index 00000000..9419d2a2 --- /dev/null +++ b/mj2/MJ2_codec/readme.txt @@ -0,0 +1,3 @@ +Attention : the motion jpeg 2000 files currently only work with OpenJPEG v0.97 that you can find here : + +http://www.openjpeg.org/openjpeg_v097.tar.gz \ No newline at end of file diff --git a/mj2/MJ2_codec/wrap_j2k_in_mj2.c b/mj2/MJ2_codec/wrap_j2k_in_mj2.c new file mode 100644 index 00000000..e777220b --- /dev/null +++ b/mj2/MJ2_codec/wrap_j2k_in_mj2.c @@ -0,0 +1,287 @@ +#include +#include +#include +#include + +#include "mj2.h" +#include +#include +#include + +#define MJ2_MJ2 0x6d6a7032 +#define MJ2_MJ2S 0x6d6a3273 +#define JP2_JP2C 0x6a703263 +#define MJ2_MDAT 0x6d646174 + +//MEMORY LEAK +#ifdef _DEBUG +#define _CRTDBG_MAP_ALLOC +#include // Must be included first +#include +#endif +//MEM + +jmp_buf j2k_error; + +void j2k_read_siz_marker(FILE *file, j2k_image_t *j2k_img) +{ + int len,i; + char buf, buf2[2]; + char *siz_buffer; + + fseek(file, 0, SEEK_SET); + do { + fread(&buf,1,1, file); + if (buf==(char)0xff) + fread(&buf,1,1, file); + } + while (!(buf==(char)0x51)); + + fread(buf2,2,1,file); /* Lsiz */ + len = ((buf2[0])<<8) + buf2[1]; + + siz_buffer = (char*) malloc(len * sizeof(char)); + fread(siz_buffer,len, 1, file); + cio_init(siz_buffer,len); + + cio_read(2); /* Rsiz (capabilities) */ + j2k_img->x1 = cio_read(4); /* Xsiz */ + j2k_img->y1 = cio_read(4); /* Ysiz */ + j2k_img->x0 = cio_read(4); /* X0siz */ + j2k_img->y0 = cio_read(4); /* Y0siz */ + cio_skip(16); /* XTsiz, YTsiz, XT0siz, YT0siz */ + + j2k_img->numcomps = cio_read(2); /* Csiz */ + j2k_img->comps = + (j2k_comp_t *) malloc(j2k_img->numcomps * sizeof(j2k_comp_t)); + for (i = 0; i < j2k_img->numcomps; i++) { + int tmp; + tmp = cio_read(1); /* Ssiz_i */ + j2k_img->comps[i].prec = (tmp & 0x7f) + 1; + j2k_img->comps[i].sgnd = tmp >> 7; + j2k_img->comps[i].dx = cio_read(1); /* XRsiz_i */ + j2k_img->comps[i].dy = cio_read(1); /* YRsiz_i */ + j2k_img->comps[i].resno_decoded = 0; /* number of resolution decoded */ + j2k_img->comps[i].factor = 0; /* reducing factor by component */ + } + free(siz_buffer); + fseek(file, 0, SEEK_SET); +} + +void setparams(mj2_movie_t *movie, j2k_image_t *img) { + int i, depth_0, depth, sign; + + movie->tk[0].sample_rate = 25; + movie->tk[0].w = int_ceildiv(img->x1 - img->x0, img->comps[0].dx); + movie->tk[0].h = int_ceildiv(img->y1 - img->y0, img->comps[0].dy); + mj2_init_stdmovie(movie); + + movie->tk[0].depth = img->comps[0].prec; + + if (img->numcomps==3) { + if ((img->comps[0].dx == 1) && (img->comps[1].dx == 1) && (img->comps[1].dx == 1)) + movie->tk[0].CbCr_subsampling_dx = 1; + else if ((img->comps[0].dx == 1) && (img->comps[1].dx == 2) && (img->comps[1].dx == 2)) + movie->tk[0].CbCr_subsampling_dx = 2; + else + fprintf(stderr,"Image component sizes are incoherent\n"); + + if ((img->comps[0].dy == 1) && (img->comps[1].dy == 1) && (img->comps[1].dy == 1)) + movie->tk[0].CbCr_subsampling_dy = 1; + else if ((img->comps[0].dy == 1) && (img->comps[1].dy == 2) && (img->comps[1].dy == 2)) + movie->tk[0].CbCr_subsampling_dy = 2; + else + fprintf(stderr,"Image component sizes are incoherent\n"); + } + + movie->tk[0].sample_rate = 25; + + movie->tk[0].jp2_struct.numcomps = img->numcomps; // NC + jp2_init_stdjp2(&movie->tk[0].jp2_struct); + + movie->tk[0].jp2_struct.w = int_ceildiv(img->x1 - img->x0, img->comps[0].dx); + movie->tk[0].jp2_struct.h = int_ceildiv(img->y1 - img->y0, img->comps[0].dy); + + depth_0 = img->comps[0].prec - 1; + sign = img->comps[0].sgnd; + movie->tk[0].jp2_struct.bpc = depth_0 + (sign << 7); + + for (i = 1; i < img->numcomps; i++) { + depth = img->comps[i].prec - 1; + sign = img->comps[i].sgnd; + if (depth_0 != depth) + movie->tk[0].jp2_struct.bpc = 255; + } + + for (i = 0; i < img->numcomps; i++) + movie->tk[0].jp2_struct.comps[i].bpcc = + img->comps[i].prec - 1 + (img->comps[i].sgnd << 7); + + if ((img->numcomps == 1 || img->numcomps == 3) + && (movie->tk[0].jp2_struct.bpc != 255)) + movie->tk[0].jp2_struct.meth = 1; + else + movie->tk[0].jp2_struct.meth = 2; + + if (img->numcomps == 1) + movie->tk[0].jp2_struct.enumcs = 17; // Grayscale + + else if ((img->comps[0].dx == 1) && (img->comps[1].dx == 1) && (img->comps[1].dx == 1) && + (img->comps[0].dy == 1) && (img->comps[1].dy == 1) && (img->comps[1].dy == 1)) + movie->tk[0].jp2_struct.enumcs = 16; // RGB + + else if ((img->comps[0].dx == 1) && (img->comps[1].dx == 2) && (img->comps[1].dx == 2) && + (img->comps[0].dy == 1) && (img->comps[1].dy == 2) && (img->comps[1].dy == 2)) + movie->tk[0].jp2_struct.enumcs = 18; // YUV + + else + movie->tk[0].jp2_struct.enumcs = 0; // Unkown profile */ +} + +int main(int argc, char *argv[]) { + + unsigned int snum; + mj2_movie_t movie; + mj2_sample_t *sample; + unsigned char* frame_codestream; + FILE *mj2file, *j2kfile; + char j2kfilename[50]; + char *buf; + int offset, mdat_initpos; + j2k_image_t img; + int i; + + if (argc != 3) { + printf("Bad syntax: Usage: MJ2_Wrapper source_location mj2_filename\n"); + printf("Example: MJ2_Wrapper input/input output.mj2\n"); + return 1; + } + + mj2file = fopen(argv[2], "wb"); + + if (!mj2file) { + fprintf(stderr, "failed to open %s for writing\n", argv[2]); + return 1; + } + + // Initialing the movie (parameters used in the JP and FTYP boxes + movie.num_htk = 0; // No hint tracks + movie.num_stk = 0; // No sound tracks + movie.num_vtk = 1; // One video track + movie.tk = (mj2_tk_t*) malloc (sizeof(mj2_tk_t)); //Memory allocation for the video track + movie.tk[0].sample = (mj2_sample_t*) malloc (sizeof(mj2_sample_t)); + movie.tk[0].chunk = (mj2_chunk_t *) malloc(sizeof(mj2_chunk_t)); + movie.tk[0].track_type = 0; // Video track + movie.tk[0].track_ID = 1; // Track ID = 1 + movie.brand = MJ2_MJ2; // One brand: MJ2 + movie.num_cl = 2; // Two compatible brands: MJ2 and MJ2S + movie.cl = (unsigned int *) malloc(movie.num_cl * sizeof(unsigned int)); + movie.cl[0] = MJ2_MJ2; + movie.cl[1] = MJ2_MJ2S; + movie.minversion = 0; // Minimum version: 0 + + // Writing JP, FTYP and MDAT boxes + buf = (char*) malloc (300 * sizeof(char)); // Assuming that the JP and FTYP + // boxes won't be longer than 300 bytes + cio_init(buf , 300); + mj2_write_jp(); + mj2_write_ftyp(&movie); + mdat_initpos = cio_tell(); + cio_skip(4); + cio_write(MJ2_MDAT, 4); + fwrite(buf,cio_tell(),1,mj2file); + free(buf); + + // Insert each j2k codestream in a JP2C box + snum=0; + offset = 0; + while(1) + { + sample = &movie.tk[0].sample[snum]; + sprintf(j2kfilename,"%s_%d.j2k",argv[1],snum); + j2kfile = fopen(j2kfilename, "rb"); + if (!j2kfile) { + if (snum==0) { // Could not open a single codestream + fprintf(stderr, "failed to open %s for reading\n",j2kfilename); + return 1; + } + else { // Tried to open a inexistant codestream + fprintf(stdout,"%d frames created\n",snum); + break; + } + } + // Calculating offset for samples and chunks + offset += cio_tell(); + sample->offset = offset; + movie.tk[0].chunk[snum].offset = offset; // There will be one sample per chunk + + // Calculating sample size + fseek(j2kfile,0,SEEK_END); + sample->sample_size = ftell(j2kfile) + 8; // Sample size is codestream + JP2C box header + fseek(j2kfile,0,SEEK_SET); + + // Reading siz marker of j2k image for the first codestream + if (snum==0) + j2k_read_siz_marker(j2kfile, &img); + + // Writing JP2C box header + frame_codestream = (unsigned char*) malloc (sample->sample_size+8); + cio_init(frame_codestream, sample->sample_size); + cio_write(sample->sample_size, 4); // Sample size + cio_write(JP2_JP2C, 4); // JP2C + + // Writing codestream from J2K file to MJ2 file + fread(frame_codestream+8,sample->sample_size-8,1,j2kfile); + fwrite(frame_codestream,sample->sample_size,1,mj2file); + cio_skip(sample->sample_size-8); + + // Ending loop + fclose(j2kfile); + snum++; + movie.tk[0].sample = realloc(movie.tk[0].sample, (snum+1) * sizeof(mj2_sample_t)); + movie.tk[0].chunk = realloc(movie.tk[0].chunk, (snum+1) * sizeof(mj2_chunk_t)); + free(frame_codestream); + } + + // Writing the MDAT box length in header + offset += cio_tell(); + buf = (char*) malloc (4 * sizeof(char)); + cio_init(buf,4); + cio_write(offset-mdat_initpos,4); // Write MDAT length in MDAT box header + fseek(mj2file,(long)mdat_initpos,SEEK_SET); + fwrite(buf,4,1,mj2file); + fseek(mj2file,0,SEEK_END); + free(buf); + + // Setting movie parameters + movie.tk[0].num_samples=snum; + movie.tk[0].num_chunks=snum; + setparams(&movie, &img); + + // Writing MOOV box + i=1; + buf = (char*) malloc (10000 * sizeof(char)); + cio_init(buf , i*10000); + if (setjmp(j2k_error)) { + i++; + buf = realloc(buf,i*10000* sizeof(char)); + cio_init(buf , i*10000); + } + mj2_write_moov(&movie); + fwrite(buf,cio_tell(),1,mj2file); + + // Ending program + fclose(mj2file); + free(img.comps); + free(buf); + mj2_memory_free(&movie); + + + //MEMORY LEAK + #ifdef _DEBUG + _CrtDumpMemoryLeaks(); + #endif + //MEM + + return 0; +} \ No newline at end of file