1 /*****************************************************************************
3 *****************************************************************************
4 * Copyright (C) 2012-2014 L-SMASH project
6 * Authors: Yusuke Nakamura <muken.the.vfrmaniac@gmail.com>
8 * Permission to use, copy, modify, and/or distribute this software for any
9 * purpose with or without fee is hereby granted, provided that the above
10 * copyright notice and this permission notice appear in all copies.
12 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
13 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
14 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
15 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
16 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
17 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
18 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
19 *****************************************************************************/
21 /* This file is available under an ISC license. */
23 #include "common/internal.h" /* must be placed first */
33 #include "description.h"
35 typedef isom_wave_t lsmash_qt_decoder_parameters_t
;
37 static void global_destruct_specific_data( void *data
)
41 lsmash_codec_global_header_t
*global
= (lsmash_codec_global_header_t
*)data
;
42 lsmash_free( global
->header_data
);
43 lsmash_free( global
);
46 static int isom_is_qt_video( lsmash_codec_type_t type
)
48 return lsmash_check_codec_type_identical( type
, QT_CODEC_TYPE_2VUY_VIDEO
)
49 || lsmash_check_codec_type_identical( type
, QT_CODEC_TYPE_APCH_VIDEO
)
50 || lsmash_check_codec_type_identical( type
, QT_CODEC_TYPE_APCN_VIDEO
)
51 || lsmash_check_codec_type_identical( type
, QT_CODEC_TYPE_APCS_VIDEO
)
52 || lsmash_check_codec_type_identical( type
, QT_CODEC_TYPE_APCO_VIDEO
)
53 || lsmash_check_codec_type_identical( type
, QT_CODEC_TYPE_AP4H_VIDEO
)
54 || lsmash_check_codec_type_identical( type
, QT_CODEC_TYPE_CFHD_VIDEO
)
55 || lsmash_check_codec_type_identical( type
, QT_CODEC_TYPE_CIVD_VIDEO
)
56 || lsmash_check_codec_type_identical( type
, QT_CODEC_TYPE_DVC_VIDEO
)
57 || lsmash_check_codec_type_identical( type
, QT_CODEC_TYPE_DVCP_VIDEO
)
58 || lsmash_check_codec_type_identical( type
, QT_CODEC_TYPE_DVPP_VIDEO
)
59 || lsmash_check_codec_type_identical( type
, QT_CODEC_TYPE_DV5N_VIDEO
)
60 || lsmash_check_codec_type_identical( type
, QT_CODEC_TYPE_DV5P_VIDEO
)
61 || lsmash_check_codec_type_identical( type
, QT_CODEC_TYPE_DVH2_VIDEO
)
62 || lsmash_check_codec_type_identical( type
, QT_CODEC_TYPE_DVH3_VIDEO
)
63 || lsmash_check_codec_type_identical( type
, QT_CODEC_TYPE_DVH5_VIDEO
)
64 || lsmash_check_codec_type_identical( type
, QT_CODEC_TYPE_DVH6_VIDEO
)
65 || lsmash_check_codec_type_identical( type
, QT_CODEC_TYPE_DVHP_VIDEO
)
66 || lsmash_check_codec_type_identical( type
, QT_CODEC_TYPE_DVHQ_VIDEO
)
67 || lsmash_check_codec_type_identical( type
, QT_CODEC_TYPE_DV10_VIDEO
)
68 || lsmash_check_codec_type_identical( type
, QT_CODEC_TYPE_DVOO_VIDEO
)
69 || lsmash_check_codec_type_identical( type
, QT_CODEC_TYPE_DVOR_VIDEO
)
70 || lsmash_check_codec_type_identical( type
, QT_CODEC_TYPE_DVTV_VIDEO
)
71 || lsmash_check_codec_type_identical( type
, QT_CODEC_TYPE_DVVT_VIDEO
)
72 || lsmash_check_codec_type_identical( type
, QT_CODEC_TYPE_FLIC_VIDEO
)
73 || lsmash_check_codec_type_identical( type
, QT_CODEC_TYPE_GIF_VIDEO
)
74 || lsmash_check_codec_type_identical( type
, QT_CODEC_TYPE_H261_VIDEO
)
75 || lsmash_check_codec_type_identical( type
, QT_CODEC_TYPE_H263_VIDEO
)
76 || lsmash_check_codec_type_identical( type
, QT_CODEC_TYPE_HD10_VIDEO
)
77 || lsmash_check_codec_type_identical( type
, QT_CODEC_TYPE_JPEG_VIDEO
)
78 || lsmash_check_codec_type_identical( type
, QT_CODEC_TYPE_M105_VIDEO
)
79 || lsmash_check_codec_type_identical( type
, QT_CODEC_TYPE_MJPA_VIDEO
)
80 || lsmash_check_codec_type_identical( type
, QT_CODEC_TYPE_MJPB_VIDEO
)
81 || lsmash_check_codec_type_identical( type
, QT_CODEC_TYPE_PNG_VIDEO
)
82 || lsmash_check_codec_type_identical( type
, QT_CODEC_TYPE_PNTG_VIDEO
)
83 || lsmash_check_codec_type_identical( type
, QT_CODEC_TYPE_RAW_VIDEO
)
84 || lsmash_check_codec_type_identical( type
, QT_CODEC_TYPE_RLE_VIDEO
)
85 || lsmash_check_codec_type_identical( type
, QT_CODEC_TYPE_RPZA_VIDEO
)
86 || lsmash_check_codec_type_identical( type
, QT_CODEC_TYPE_SHR0_VIDEO
)
87 || lsmash_check_codec_type_identical( type
, QT_CODEC_TYPE_SHR1_VIDEO
)
88 || lsmash_check_codec_type_identical( type
, QT_CODEC_TYPE_SHR2_VIDEO
)
89 || lsmash_check_codec_type_identical( type
, QT_CODEC_TYPE_SHR3_VIDEO
)
90 || lsmash_check_codec_type_identical( type
, QT_CODEC_TYPE_SHR4_VIDEO
)
91 || lsmash_check_codec_type_identical( type
, QT_CODEC_TYPE_SVQ1_VIDEO
)
92 || lsmash_check_codec_type_identical( type
, QT_CODEC_TYPE_SVQ3_VIDEO
)
93 || lsmash_check_codec_type_identical( type
, QT_CODEC_TYPE_TGA_VIDEO
)
94 || lsmash_check_codec_type_identical( type
, QT_CODEC_TYPE_TIFF_VIDEO
)
95 || lsmash_check_codec_type_identical( type
, QT_CODEC_TYPE_ULRA_VIDEO
)
96 || lsmash_check_codec_type_identical( type
, QT_CODEC_TYPE_ULRG_VIDEO
)
97 || lsmash_check_codec_type_identical( type
, QT_CODEC_TYPE_ULY2_VIDEO
)
98 || lsmash_check_codec_type_identical( type
, QT_CODEC_TYPE_ULY0_VIDEO
)
99 || lsmash_check_codec_type_identical( type
, QT_CODEC_TYPE_ULH2_VIDEO
)
100 || lsmash_check_codec_type_identical( type
, QT_CODEC_TYPE_ULH0_VIDEO
)
101 || lsmash_check_codec_type_identical( type
, QT_CODEC_TYPE_UQY2_VIDEO
)
102 || lsmash_check_codec_type_identical( type
, QT_CODEC_TYPE_V210_VIDEO
)
103 || lsmash_check_codec_type_identical( type
, QT_CODEC_TYPE_V216_VIDEO
)
104 || lsmash_check_codec_type_identical( type
, QT_CODEC_TYPE_V308_VIDEO
)
105 || lsmash_check_codec_type_identical( type
, QT_CODEC_TYPE_V408_VIDEO
)
106 || lsmash_check_codec_type_identical( type
, QT_CODEC_TYPE_V410_VIDEO
)
107 || lsmash_check_codec_type_identical( type
, QT_CODEC_TYPE_YUV2_VIDEO
)
108 || lsmash_check_codec_type_identical( type
, QT_CODEC_TYPE_WRLE_VIDEO
);
111 static int isom_is_nalff( lsmash_codec_type_t type
)
113 return lsmash_check_codec_type_identical( type
, ISOM_CODEC_TYPE_AVC1_VIDEO
)
114 || lsmash_check_codec_type_identical( type
, ISOM_CODEC_TYPE_AVC2_VIDEO
)
115 || lsmash_check_codec_type_identical( type
, ISOM_CODEC_TYPE_AVC3_VIDEO
)
116 || lsmash_check_codec_type_identical( type
, ISOM_CODEC_TYPE_AVC4_VIDEO
)
117 || lsmash_check_codec_type_identical( type
, ISOM_CODEC_TYPE_AVCP_VIDEO
)
118 || lsmash_check_codec_type_identical( type
, ISOM_CODEC_TYPE_HVC1_VIDEO
)
119 || lsmash_check_codec_type_identical( type
, ISOM_CODEC_TYPE_HEV1_VIDEO
);
122 int lsmash_convert_crop_into_clap( lsmash_crop_t crop
, uint32_t width
, uint32_t height
, lsmash_clap_t
*clap
)
124 if( !clap
|| crop
.top
.d
== 0 || crop
.bottom
.d
== 0 || crop
.left
.d
== 0 || crop
.right
.d
== 0 )
125 return LSMASH_ERR_FUNCTION_PARAM
;
126 uint64_t vertical_crop_lcm
= lsmash_get_lcm( crop
.top
.d
, crop
.bottom
.d
);
127 uint64_t horizontal_crop_lcm
= lsmash_get_lcm( crop
.left
.d
, crop
.right
.d
);
128 lsmash_rational_u64_t clap_height
;
129 lsmash_rational_u64_t clap_width
;
130 lsmash_rational_s64_t clap_horizontal_offset
;
131 lsmash_rational_s64_t clap_vertical_offset
;
132 clap_height
.d
= vertical_crop_lcm
;
133 clap_width
.d
= horizontal_crop_lcm
;
134 clap_horizontal_offset
.d
= 2 * vertical_crop_lcm
;
135 clap_vertical_offset
.d
= 2 * horizontal_crop_lcm
;
136 clap_height
.n
= height
* vertical_crop_lcm
137 - (crop
.top
.n
* (vertical_crop_lcm
/ crop
.top
.d
) + crop
.bottom
.n
* (vertical_crop_lcm
/ crop
.bottom
.d
));
138 clap_width
.n
= width
* horizontal_crop_lcm
139 - (crop
.left
.n
* (horizontal_crop_lcm
/ crop
.left
.d
) + crop
.right
.n
* (horizontal_crop_lcm
/ crop
.right
.d
));
140 clap_horizontal_offset
.n
= (int64_t)(crop
.left
.n
* (horizontal_crop_lcm
/ crop
.left
.d
))
141 - crop
.right
.n
* (horizontal_crop_lcm
/ crop
.right
.d
);
142 clap_vertical_offset
.n
= (int64_t)(crop
.top
.n
* (vertical_crop_lcm
/ crop
.top
.d
))
143 - crop
.bottom
.n
* (vertical_crop_lcm
/ crop
.bottom
.d
);
144 lsmash_reduce_fraction( &clap_height
.n
, &clap_height
.d
);
145 lsmash_reduce_fraction( &clap_width
.n
, &clap_width
.d
);
146 lsmash_reduce_fraction_su( &clap_vertical_offset
.n
, &clap_vertical_offset
.d
);
147 lsmash_reduce_fraction_su( &clap_horizontal_offset
.n
, &clap_horizontal_offset
.d
);
148 clap
->height
= (lsmash_rational_u32_t
){ clap_height
.n
, clap_height
.d
};
149 clap
->width
= (lsmash_rational_u32_t
){ clap_width
.n
, clap_width
.d
};
150 clap
->vertical_offset
= (lsmash_rational_s32_t
){ clap_vertical_offset
.n
, clap_vertical_offset
.d
};
151 clap
->horizontal_offset
= (lsmash_rational_s32_t
){ clap_horizontal_offset
.n
, clap_horizontal_offset
.d
};
155 int lsmash_convert_clap_into_crop( lsmash_clap_t clap
, uint32_t width
, uint32_t height
, lsmash_crop_t
*crop
)
157 if( !crop
|| clap
.height
.d
== 0 || clap
.vertical_offset
.d
== 0 || clap
.width
.d
== 0 || clap
.horizontal_offset
.d
== 0 )
158 return LSMASH_ERR_FUNCTION_PARAM
;
159 uint64_t clap_vertical_lcm
= lsmash_get_lcm( clap
.height
.d
, clap
.vertical_offset
.d
);
160 uint64_t clap_horizontal_lcm
= lsmash_get_lcm( clap
.width
.d
, clap
.horizontal_offset
.d
);
161 lsmash_rational_u64_t crop_top
;
162 lsmash_rational_u64_t crop_bottom
;
163 lsmash_rational_u64_t crop_left
;
164 lsmash_rational_u64_t crop_right
;
165 crop_top
.d
= 2 * clap_vertical_lcm
;
166 crop_bottom
.d
= 2 * clap_vertical_lcm
;
167 crop_left
.d
= 2 * clap_horizontal_lcm
;
168 crop_right
.d
= 2 * clap_horizontal_lcm
;
169 crop_top
.n
= (height
* crop_top
.d
- clap
.height
.n
* (crop_top
.d
/ clap
.height
.d
)) / 2
170 + clap
.vertical_offset
.n
* (crop_top
.d
/ clap
.vertical_offset
.d
);
171 crop_bottom
.n
= (height
* crop_bottom
.d
- clap
.height
.n
* (crop_bottom
.d
/ clap
.height
.d
)) / 2
172 - clap
.vertical_offset
.n
* (crop_bottom
.d
/ clap
.vertical_offset
.d
);
173 crop_left
.n
= (width
* crop_left
.d
- clap
.width
.n
* (crop_left
.d
/ clap
.width
.d
)) / 2
174 + clap
.horizontal_offset
.n
* (crop_left
.d
/ clap
.horizontal_offset
.d
);
175 crop_right
.n
= (width
* crop_right
.d
- clap
.width
.n
* (crop_right
.d
/ clap
.width
.d
)) / 2
176 - clap
.horizontal_offset
.n
* (crop_right
.d
/ clap
.horizontal_offset
.d
);
177 lsmash_reduce_fraction( &crop_top
.n
, &crop_top
.d
);
178 lsmash_reduce_fraction( &crop_bottom
.n
, &crop_bottom
.d
);
179 lsmash_reduce_fraction( &crop_left
.n
, &crop_left
.d
);
180 lsmash_reduce_fraction( &crop_right
.n
, &crop_right
.d
);
181 crop
->top
= (lsmash_rational_u32_t
){ crop_top
.n
, crop_top
.d
};
182 crop
->bottom
= (lsmash_rational_u32_t
){ crop_bottom
.n
, crop_bottom
.d
};
183 crop
->left
= (lsmash_rational_u32_t
){ crop_left
.n
, crop_left
.d
};
184 crop
->right
= (lsmash_rational_u32_t
){ crop_right
.n
, crop_right
.d
};
188 static void isom_destruct_nothing( void *data
)
193 static int isom_initialize_structured_codec_specific_data( lsmash_codec_specific_t
*specific
)
195 extern void mp4sys_destruct_decoder_config( void * );
196 extern void h264_destruct_specific_data( void * );
197 extern void hevc_destruct_specific_data( void * );
198 extern void vc1_destruct_specific_data( void * );
199 extern void dts_destruct_specific_data( void * );
200 switch( specific
->type
)
202 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_MP4SYS_DECODER_CONFIG
:
203 specific
->size
= sizeof(lsmash_mp4sys_decoder_parameters_t
);
204 specific
->destruct
= mp4sys_destruct_decoder_config
;
206 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_VIDEO_H264
:
207 specific
->size
= sizeof(lsmash_h264_specific_parameters_t
);
208 specific
->destruct
= h264_destruct_specific_data
;
210 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_VIDEO_HEVC
:
211 specific
->size
= sizeof(lsmash_hevc_specific_parameters_t
);
212 specific
->destruct
= hevc_destruct_specific_data
;
214 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_VIDEO_VC_1
:
215 specific
->size
= sizeof(lsmash_vc1_specific_parameters_t
);
216 specific
->destruct
= vc1_destruct_specific_data
;
218 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_AUDIO_AC_3
:
219 specific
->size
= sizeof(lsmash_ac3_specific_parameters_t
);
220 specific
->destruct
= lsmash_free
;
222 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_AUDIO_EC_3
:
223 specific
->size
= sizeof(lsmash_eac3_specific_parameters_t
);
224 specific
->destruct
= lsmash_free
;
226 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_AUDIO_DTS
:
227 specific
->size
= sizeof(lsmash_dts_specific_parameters_t
);
228 specific
->destruct
= dts_destruct_specific_data
;
230 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_AUDIO_ALAC
:
231 specific
->size
= sizeof(lsmash_alac_specific_parameters_t
);
232 specific
->destruct
= lsmash_free
;
234 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_VIDEO_SAMPLE_SCALE
:
235 specific
->size
= sizeof(lsmash_isom_sample_scale_t
);
236 specific
->destruct
= lsmash_free
;
238 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_VIDEO_H264_BITRATE
:
239 specific
->size
= sizeof(lsmash_h264_bitrate_t
);
240 specific
->destruct
= lsmash_free
;
242 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_VIDEO_COMMON
:
243 specific
->size
= sizeof(lsmash_qt_video_common_t
);
244 specific
->destruct
= lsmash_free
;
246 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_AUDIO_COMMON
:
247 specific
->size
= sizeof(lsmash_qt_audio_common_t
);
248 specific
->destruct
= lsmash_free
;
250 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_AUDIO_FORMAT_SPECIFIC_FLAGS
:
251 specific
->size
= sizeof(lsmash_qt_audio_format_specific_flags_t
);
252 specific
->destruct
= lsmash_free
;
254 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_CODEC_GLOBAL_HEADER
:
255 specific
->size
= sizeof(lsmash_codec_global_header_t
);
256 specific
->destruct
= global_destruct_specific_data
;
258 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_VIDEO_FIELD_INFO
:
259 specific
->size
= sizeof(lsmash_qt_field_info_t
);
260 specific
->destruct
= lsmash_free
;
262 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_VIDEO_PIXEL_FORMAT
:
263 specific
->size
= sizeof(lsmash_qt_pixel_format_t
);
264 specific
->destruct
= lsmash_free
;
266 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_VIDEO_SIGNIFICANT_BITS
:
267 specific
->size
= sizeof(lsmash_qt_significant_bits_t
);
268 specific
->destruct
= lsmash_free
;
270 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_AUDIO_CHANNEL_LAYOUT
:
271 specific
->size
= sizeof(lsmash_qt_audio_channel_layout_t
);
272 specific
->destruct
= lsmash_free
;
276 specific
->destruct
= isom_destruct_nothing
;
279 specific
->data
.structured
= lsmash_malloc_zero( specific
->size
);
280 if( !specific
->data
.structured
)
283 specific
->destruct
= NULL
;
284 return LSMASH_ERR_MEMORY_ALLOC
;
289 static inline int isom_initialize_codec_specific_data( lsmash_codec_specific_t
*specific
,
290 lsmash_codec_specific_data_type type
,
291 lsmash_codec_specific_format format
)
293 specific
->type
= type
;
294 specific
->format
= format
;
295 if( format
== LSMASH_CODEC_SPECIFIC_FORMAT_STRUCTURED
)
297 int err
= isom_initialize_structured_codec_specific_data( specific
);
303 specific
->data
.unstructured
= NULL
;
305 specific
->destruct
= (lsmash_codec_specific_destructor_t
)lsmash_free
;
310 void lsmash_destroy_codec_specific_data( lsmash_codec_specific_t
*specific
)
314 if( specific
->destruct
)
316 if( specific
->format
== LSMASH_CODEC_SPECIFIC_FORMAT_STRUCTURED
)
318 if( specific
->data
.structured
)
319 specific
->destruct( specific
->data
.structured
);
323 if( specific
->data
.unstructured
)
324 specific
->destruct( specific
->data
.unstructured
);
327 lsmash_free( specific
);
330 lsmash_codec_specific_t
*lsmash_create_codec_specific_data( lsmash_codec_specific_data_type type
, lsmash_codec_specific_format format
)
332 lsmash_codec_specific_t
*specific
= lsmash_malloc( sizeof(lsmash_codec_specific_t
) );
335 if( isom_initialize_codec_specific_data( specific
, type
, format
) < 0 )
337 lsmash_destroy_codec_specific_data( specific
);
343 static int isom_duplicate_structured_specific_data( lsmash_codec_specific_t
*dst
, lsmash_codec_specific_t
*src
)
345 extern int mp4sys_copy_decoder_config( lsmash_codec_specific_t
*, lsmash_codec_specific_t
* );
346 extern int h264_copy_codec_specific( lsmash_codec_specific_t
*, lsmash_codec_specific_t
* );
347 extern int hevc_copy_codec_specific( lsmash_codec_specific_t
*, lsmash_codec_specific_t
* );
348 extern int vc1_copy_codec_specific( lsmash_codec_specific_t
*, lsmash_codec_specific_t
* );
349 extern int dts_copy_codec_specific( lsmash_codec_specific_t
*, lsmash_codec_specific_t
* );
350 void *src_data
= src
->data
.structured
;
351 void *dst_data
= dst
->data
.structured
;
354 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_MP4SYS_DECODER_CONFIG
:
355 return mp4sys_copy_decoder_config( dst
, src
);
356 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_VIDEO_H264
:
357 return h264_copy_codec_specific( dst
, src
);
358 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_VIDEO_HEVC
:
359 return hevc_copy_codec_specific( dst
, src
);
360 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_VIDEO_VC_1
:
361 return vc1_copy_codec_specific( dst
, src
);
362 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_AUDIO_AC_3
:
363 *(lsmash_ac3_specific_parameters_t
*)dst_data
= *(lsmash_ac3_specific_parameters_t
*)src_data
;
365 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_AUDIO_EC_3
:
366 *(lsmash_eac3_specific_parameters_t
*)dst_data
= *(lsmash_eac3_specific_parameters_t
*)src_data
;
368 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_AUDIO_DTS
:
369 return dts_copy_codec_specific( dst
, src
);
370 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_AUDIO_ALAC
:
371 *(lsmash_alac_specific_parameters_t
*)dst_data
= *(lsmash_alac_specific_parameters_t
*)src_data
;
373 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_VIDEO_SAMPLE_SCALE
:
374 *(lsmash_isom_sample_scale_t
*)dst_data
= *(lsmash_isom_sample_scale_t
*)src_data
;
376 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_VIDEO_H264_BITRATE
:
377 *(lsmash_h264_bitrate_t
*)dst_data
= *(lsmash_h264_bitrate_t
*)src_data
;
379 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_VIDEO_COMMON
:
380 *(lsmash_qt_video_common_t
*)dst_data
= *(lsmash_qt_video_common_t
*)src_data
;
382 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_AUDIO_COMMON
:
383 *(lsmash_qt_audio_common_t
*)dst_data
= *(lsmash_qt_audio_common_t
*)src_data
;
385 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_AUDIO_FORMAT_SPECIFIC_FLAGS
:
386 *(lsmash_qt_audio_format_specific_flags_t
*)dst_data
= *(lsmash_qt_audio_format_specific_flags_t
*)src_data
;
388 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_CODEC_GLOBAL_HEADER
:
390 lsmash_codec_global_header_t
*src_global
= (lsmash_codec_global_header_t
*)src_data
;
391 if( src_global
->header_data
&& src_global
->header_size
)
393 lsmash_codec_global_header_t
*dst_global
= (lsmash_codec_global_header_t
*)dst_data
;
394 dst_global
->header_data
= lsmash_memdup( src_global
->header_data
, src_global
->header_size
);
395 if( !dst_global
->header_data
)
396 return LSMASH_ERR_MEMORY_ALLOC
;
397 dst_global
->header_size
= src_global
->header_size
;
401 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_VIDEO_FIELD_INFO
:
402 *(lsmash_qt_field_info_t
*)dst_data
= *(lsmash_qt_field_info_t
*)src_data
;
404 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_VIDEO_PIXEL_FORMAT
:
405 *(lsmash_qt_pixel_format_t
*)dst_data
= *(lsmash_qt_pixel_format_t
*)src_data
;
407 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_VIDEO_SIGNIFICANT_BITS
:
408 *(lsmash_qt_significant_bits_t
*)dst_data
= *(lsmash_qt_significant_bits_t
*)src_data
;
410 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_VIDEO_GAMMA_LEVEL
:
411 *(lsmash_qt_gamma_t
*)dst_data
= *(lsmash_qt_gamma_t
*)src_data
;
413 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_AUDIO_CHANNEL_LAYOUT
:
414 *(lsmash_qt_audio_channel_layout_t
*)dst_data
= *(lsmash_qt_audio_channel_layout_t
*)src_data
;
417 return LSMASH_ERR_NAMELESS
;
421 lsmash_codec_specific_t
*isom_duplicate_codec_specific_data( lsmash_codec_specific_t
*specific
)
425 lsmash_codec_specific_t
*dup
= lsmash_create_codec_specific_data( specific
->type
, specific
->format
);
428 if( specific
->format
== LSMASH_CODEC_SPECIFIC_FORMAT_STRUCTURED
)
430 if( isom_duplicate_structured_specific_data( dup
, specific
) < 0 )
432 lsmash_destroy_codec_specific_data( dup
);
438 dup
->data
.unstructured
= lsmash_memdup( specific
->data
.unstructured
, specific
->size
);
439 if( !dup
->data
.unstructured
)
441 lsmash_destroy_codec_specific_data( dup
);
445 dup
->size
= specific
->size
;
449 static size_t isom_description_read_box_common( uint8_t **p_data
, uint64_t *size
, lsmash_box_type_t
*type
)
451 uint8_t *orig
= *p_data
;
452 uint8_t *data
= *p_data
;
453 *size
= LSMASH_GET_BE32( &data
[0] );
454 type
->fourcc
= LSMASH_GET_BE32( &data
[4] );
455 data
+= ISOM_BASEBOX_COMMON_SIZE
;
458 *size
= LSMASH_GET_BE64( data
);
462 if( type
->fourcc
== ISOM_BOX_TYPE_UUID
.fourcc
)
464 type
->user
.fourcc
= LSMASH_GET_BE32( &data
[0] );
465 memcpy( type
->user
.id
, &data
[4], 12 );
470 uint8_t *isom_get_child_box_position( uint8_t *parent_data
, uint32_t parent_size
, lsmash_box_type_t child_type
, uint32_t *child_size
)
472 if( !parent_data
|| !child_size
|| parent_size
< ISOM_BASEBOX_COMMON_SIZE
)
474 uint8_t *data
= parent_data
;
476 lsmash_box_type_t type
;
477 uint32_t offset
= isom_description_read_box_common( &data
, &size
, &type
);
478 if( size
!= parent_size
)
480 uint8_t *end
= parent_data
+ parent_size
;
481 for( uint8_t *pos
= data
; pos
+ ISOM_BASEBOX_COMMON_SIZE
<= end
; )
483 offset
= isom_description_read_box_common( &pos
, &size
, &type
);
484 if( lsmash_check_box_type_identical( type
, child_type
) )
489 pos
+= size
- offset
; /* Move to the next box. */
494 static int isom_construct_global_specific_header( lsmash_codec_specific_t
*dst
, lsmash_codec_specific_t
*src
)
496 if( src
->size
< ISOM_BASEBOX_COMMON_SIZE
)
497 return LSMASH_ERR_INVALID_DATA
;
498 lsmash_codec_global_header_t
*global
= (lsmash_codec_global_header_t
*)dst
->data
.structured
;
499 uint8_t *data
= src
->data
.unstructured
;
500 uint64_t size
= LSMASH_GET_BE32( data
);
501 data
+= ISOM_BASEBOX_COMMON_SIZE
;
504 size
= LSMASH_GET_BE64( data
);
507 if( size
!= src
->size
)
508 return LSMASH_ERR_INVALID_DATA
;
509 global
->header_size
= size
- ISOM_BASEBOX_COMMON_SIZE
;
510 if( data
!= src
->data
.unstructured
+ ISOM_BASEBOX_COMMON_SIZE
)
511 global
->header_size
-= 8; /* largesize */
512 if( global
->header_size
)
514 global
->header_data
= lsmash_memdup( data
, global
->header_size
);
515 if( !global
->header_data
)
516 return LSMASH_ERR_MEMORY_ALLOC
;
521 static int isom_construct_audio_channel_layout( lsmash_codec_specific_t
*dst
, lsmash_codec_specific_t
*src
)
523 if( src
->size
< ISOM_FULLBOX_COMMON_SIZE
+ 12 )
524 return LSMASH_ERR_INVALID_DATA
;
525 lsmash_qt_audio_channel_layout_t
*layout
= (lsmash_qt_audio_channel_layout_t
*)dst
->data
.structured
;
526 uint8_t *data
= src
->data
.unstructured
;
527 uint64_t size
= LSMASH_GET_BE32( data
);
528 data
+= ISOM_FULLBOX_COMMON_SIZE
;
531 size
= LSMASH_GET_BE64( data
);
534 if( size
!= src
->size
)
535 return LSMASH_ERR_INVALID_DATA
;
536 layout
->channelLayoutTag
= LSMASH_GET_BE32( &data
[0] );
537 layout
->channelBitmap
= LSMASH_GET_BE32( &data
[4] );
542 static int codec_construct_qt_audio_decompression_info( lsmash_codec_specific_t
*dst
, lsmash_codec_specific_t
*src
)
544 if( src
->size
< ISOM_BASEBOX_COMMON_SIZE
)
545 return LSMASH_ERR_INVALID_DATA
;
546 uint8_t *data
= src
->data
.unstructured
;
549 uint32_t offset
= isom_description_read_box_common( &data
, &size
, &type
);
550 if( size
!= src
->size
)
551 return LSMASH_ERR_INVALID_DATA
;
552 uint8_t *end
= src
->data
.unstructured
+ src
->size
;
553 isom_wave_t
*wave
= lsmash_malloc_zero( sizeof(isom_wave_t
) );
555 return LSMASH_ERR_MEMORY_ALLOC
;
556 wave
->type
= QT_BOX_TYPE_WAVE
;
557 for( uint8_t *pos
= data
; pos
+ ISOM_BASEBOX_COMMON_SIZE
<= end
; )
559 offset
= isom_description_read_box_common( &pos
, &size
, &type
);
562 case QT_BOX_TYPE_FRMA
:
565 return LSMASH_ERR_INVALID_DATA
;
566 isom_frma_t
*frma
= isom_add_frma( wave
);
568 return LSMASH_ERR_NAMELESS
;
569 frma
->data_format
= LSMASH_GET_BE32( pos
);
573 case QT_BOX_TYPE_ENDA
:
576 return LSMASH_ERR_INVALID_DATA
;
577 isom_enda_t
*enda
= isom_add_enda( wave
);
579 return LSMASH_ERR_NAMELESS
;
580 enda
->littleEndian
= LSMASH_GET_BE16( pos
);
583 case QT_BOX_TYPE_MP4A
:
586 return LSMASH_ERR_INVALID_DATA
;
587 isom_mp4a_t
*mp4a
= isom_add_mp4a( wave
);
589 return LSMASH_ERR_NAMELESS
;
590 mp4a
->unknown
= LSMASH_GET_BE32( pos
);
594 case QT_BOX_TYPE_TERMINATOR
:
596 if( !isom_add_terminator( wave
) )
597 return LSMASH_ERR_NAMELESS
;
602 isom_unknown_box_t
*box
= lsmash_malloc_zero( sizeof(isom_unknown_box_t
) );
604 return LSMASH_ERR_MEMORY_ALLOC
;
605 isom_init_box_common( box
, wave
, type
, isom_remove_unknown_box
);
606 box
->unknown_size
= size
- offset
;
607 box
->unknown_field
= lsmash_memdup( pos
, box
->unknown_size
);
608 if( !box
->unknown_field
)
611 return LSMASH_ERR_MEMORY_ALLOC
;
613 if( lsmash_add_entry( &wave
->extensions
, box
) < 0 )
615 isom_remove_unknown_box( box
);
616 return LSMASH_ERR_MEMORY_ALLOC
;
618 pos
+= box
->unknown_size
;
627 /* structured <-> unstructured conversion might be irreversible by CODEC
628 * since structured formats we defined don't always have all contents included in unstructured data. */
629 lsmash_codec_specific_t
*lsmash_convert_codec_specific_format( lsmash_codec_specific_t
*specific
, lsmash_codec_specific_format format
)
631 if( !specific
|| format
== LSMASH_CODEC_SPECIFIC_FORMAT_UNSPECIFIED
)
633 if( format
== specific
->format
)
634 return isom_duplicate_codec_specific_data( specific
);
635 lsmash_codec_specific_t
*dst
= lsmash_create_codec_specific_data( specific
->type
, format
);
638 if( format
== LSMASH_CODEC_SPECIFIC_FORMAT_UNSTRUCTURED
)
639 /* structured -> unstructured */
640 switch( specific
->type
)
642 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_MP4SYS_DECODER_CONFIG
:
643 dst
->data
.unstructured
= lsmash_create_mp4sys_decoder_config( (lsmash_mp4sys_decoder_parameters_t
*)specific
->data
.structured
, &dst
->size
);
644 if( !dst
->data
.unstructured
)
647 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_VIDEO_H264
:
648 dst
->data
.unstructured
= lsmash_create_h264_specific_info( (lsmash_h264_specific_parameters_t
*)specific
->data
.structured
, &dst
->size
);
649 if( !dst
->data
.unstructured
)
652 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_VIDEO_HEVC
:
653 dst
->data
.unstructured
= lsmash_create_hevc_specific_info( (lsmash_hevc_specific_parameters_t
*)specific
->data
.structured
, &dst
->size
);
654 if( !dst
->data
.unstructured
)
657 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_VIDEO_VC_1
:
658 dst
->data
.unstructured
= lsmash_create_vc1_specific_info( (lsmash_vc1_specific_parameters_t
*)specific
->data
.structured
, &dst
->size
);
659 if( !dst
->data
.unstructured
)
662 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_AUDIO_AC_3
:
663 dst
->data
.unstructured
= lsmash_create_ac3_specific_info( (lsmash_ac3_specific_parameters_t
*)specific
->data
.structured
, &dst
->size
);
664 if( !dst
->data
.unstructured
)
667 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_AUDIO_EC_3
:
668 dst
->data
.unstructured
= lsmash_create_eac3_specific_info( (lsmash_eac3_specific_parameters_t
*)specific
->data
.structured
, &dst
->size
);
669 if( !dst
->data
.unstructured
)
672 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_AUDIO_DTS
:
673 dst
->data
.unstructured
= lsmash_create_dts_specific_info( (lsmash_dts_specific_parameters_t
*)specific
->data
.structured
, &dst
->size
);
674 if( !dst
->data
.unstructured
)
677 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_AUDIO_ALAC
:
678 dst
->data
.unstructured
= lsmash_create_alac_specific_info( (lsmash_alac_specific_parameters_t
*)specific
->data
.structured
, &dst
->size
);
679 if( !dst
->data
.unstructured
)
682 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_CODEC_GLOBAL_HEADER
:
684 lsmash_bs_t
*bs
= lsmash_bs_create();
687 lsmash_codec_global_header_t
*global
= specific
->data
.structured
;
688 lsmash_bs_put_be32( bs
, ISOM_BASEBOX_COMMON_SIZE
+ global
->header_size
);
689 lsmash_bs_put_be32( bs
, QT_BOX_TYPE_GLBL
.fourcc
);
690 lsmash_bs_put_bytes( bs
, global
->header_size
, global
->header_data
);
691 dst
->data
.unstructured
= lsmash_bs_export_data( bs
, &dst
->size
);
692 lsmash_bs_cleanup( bs
);
693 if( !dst
->data
.unstructured
|| dst
->size
!= (ISOM_BASEBOX_COMMON_SIZE
+ global
->header_size
) )
700 else if( format
== LSMASH_CODEC_SPECIFIC_FORMAT_STRUCTURED
)
702 /* unstructured -> structured */
703 extern int mp4sys_construct_decoder_config( lsmash_codec_specific_t
*, lsmash_codec_specific_t
* );
704 extern int h264_construct_specific_parameters( lsmash_codec_specific_t
*, lsmash_codec_specific_t
* );
705 extern int hevc_construct_specific_parameters( lsmash_codec_specific_t
*, lsmash_codec_specific_t
* );
706 extern int vc1_construct_specific_parameters( lsmash_codec_specific_t
*, lsmash_codec_specific_t
* );
707 extern int ac3_construct_specific_parameters( lsmash_codec_specific_t
*, lsmash_codec_specific_t
* );
708 extern int eac3_construct_specific_parameters( lsmash_codec_specific_t
*, lsmash_codec_specific_t
* );
709 extern int dts_construct_specific_parameters( lsmash_codec_specific_t
*, lsmash_codec_specific_t
* );
710 extern int alac_construct_specific_parameters( lsmash_codec_specific_t
*, lsmash_codec_specific_t
* );
713 lsmash_codec_specific_data_type data_type
;
714 int (*constructor
)( lsmash_codec_specific_t
*, lsmash_codec_specific_t
* );
715 } codec_specific_format_constructor_table
[] =
717 { LSMASH_CODEC_SPECIFIC_DATA_TYPE_MP4SYS_DECODER_CONFIG
, mp4sys_construct_decoder_config
},
718 { LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_VIDEO_H264
, h264_construct_specific_parameters
},
719 { LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_VIDEO_HEVC
, hevc_construct_specific_parameters
},
720 { LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_VIDEO_VC_1
, vc1_construct_specific_parameters
},
721 { LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_AUDIO_AC_3
, ac3_construct_specific_parameters
},
722 { LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_AUDIO_EC_3
, eac3_construct_specific_parameters
},
723 { LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_AUDIO_DTS
, dts_construct_specific_parameters
},
724 { LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_AUDIO_ALAC
, alac_construct_specific_parameters
},
725 { LSMASH_CODEC_SPECIFIC_DATA_TYPE_CODEC_GLOBAL_HEADER
, isom_construct_global_specific_header
},
726 { LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_AUDIO_CHANNEL_LAYOUT
, isom_construct_audio_channel_layout
},
727 { LSMASH_CODEC_SPECIFIC_DATA_TYPE_UNKNOWN
, NULL
}
729 int (*constructor
)( lsmash_codec_specific_t
*, lsmash_codec_specific_t
* ) = NULL
;
730 for( int i
= 0; codec_specific_format_constructor_table
[i
].constructor
; i
++ )
731 if( specific
->type
== codec_specific_format_constructor_table
[i
].data_type
)
733 constructor
= codec_specific_format_constructor_table
[i
].constructor
;
736 if( constructor
&& !constructor( dst
, specific
) )
740 lsmash_destroy_codec_specific_data( dst
);
744 static inline void isom_set_default_compressorname( char *compressorname
, lsmash_codec_type_t sample_type
)
746 static struct compressorname_table_tag
748 lsmash_codec_type_t type
;
750 } compressorname_table
[32] = { { LSMASH_CODEC_TYPE_INITIALIZER
, { '\0' } } };
751 if( compressorname_table
[0].name
[0] == '\0' )
754 #define ADD_COMPRESSORNAME_TABLE( type, name ) compressorname_table[i++] = (struct compressorname_table_tag){ type, name }
755 ADD_COMPRESSORNAME_TABLE( ISOM_CODEC_TYPE_AVC1_VIDEO
, "\012AVC Coding" );
756 ADD_COMPRESSORNAME_TABLE( ISOM_CODEC_TYPE_AVC2_VIDEO
, "\012AVC Coding" );
757 ADD_COMPRESSORNAME_TABLE( ISOM_CODEC_TYPE_AVC3_VIDEO
, "\012AVC Coding" );
758 ADD_COMPRESSORNAME_TABLE( ISOM_CODEC_TYPE_AVC4_VIDEO
, "\012AVC Coding" );
759 ADD_COMPRESSORNAME_TABLE( ISOM_CODEC_TYPE_AVCP_VIDEO
, "\016AVC Parameters" );
760 ADD_COMPRESSORNAME_TABLE( ISOM_CODEC_TYPE_HVC1_VIDEO
, "\013HEVC Coding" );
761 ADD_COMPRESSORNAME_TABLE( ISOM_CODEC_TYPE_HEV1_VIDEO
, "\013HEVC Coding" );
762 ADD_COMPRESSORNAME_TABLE( ISOM_CODEC_TYPE_SVC1_VIDEO
, "\012SVC Coding" );
763 ADD_COMPRESSORNAME_TABLE( ISOM_CODEC_TYPE_MVC1_VIDEO
, "\012MVC Coding" );
764 ADD_COMPRESSORNAME_TABLE( ISOM_CODEC_TYPE_MVC2_VIDEO
, "\012MVC Coding" );
765 ADD_COMPRESSORNAME_TABLE( QT_CODEC_TYPE_APCH_VIDEO
, "\023Apple ProRes 422 (HQ)" );
766 ADD_COMPRESSORNAME_TABLE( QT_CODEC_TYPE_APCN_VIDEO
, "\023Apple ProRes 422 (SD)" );
767 ADD_COMPRESSORNAME_TABLE( QT_CODEC_TYPE_APCS_VIDEO
, "\023Apple ProRes 422 (LT)" );
768 ADD_COMPRESSORNAME_TABLE( QT_CODEC_TYPE_APCO_VIDEO
, "\026Apple ProRes 422 (Proxy)" );
769 ADD_COMPRESSORNAME_TABLE( QT_CODEC_TYPE_AP4H_VIDEO
, "\019Apple ProRes 4444" );
770 ADD_COMPRESSORNAME_TABLE( QT_CODEC_TYPE_DVPP_VIDEO
, "\014DVCPRO - PAL" );
771 ADD_COMPRESSORNAME_TABLE( QT_CODEC_TYPE_DV5N_VIDEO
, "\017DVCPRO50 - NTSC" );
772 ADD_COMPRESSORNAME_TABLE( QT_CODEC_TYPE_DV5P_VIDEO
, "\016DVCPRO50 - PAL" );
773 ADD_COMPRESSORNAME_TABLE( QT_CODEC_TYPE_DVH2_VIDEO
, "\019DVCPRO HD 1080p25" );
774 ADD_COMPRESSORNAME_TABLE( QT_CODEC_TYPE_DVH3_VIDEO
, "\019DVCPRO HD 1080p30" );
775 ADD_COMPRESSORNAME_TABLE( QT_CODEC_TYPE_DVH5_VIDEO
, "\019DVCPRO HD 1080i50" );
776 ADD_COMPRESSORNAME_TABLE( QT_CODEC_TYPE_DVH6_VIDEO
, "\019DVCPRO HD 1080i60" );
777 ADD_COMPRESSORNAME_TABLE( QT_CODEC_TYPE_DVHP_VIDEO
, "\018DVCPRO HD 720p60" );
778 ADD_COMPRESSORNAME_TABLE( QT_CODEC_TYPE_DVHQ_VIDEO
, "\018DVCPRO HD 720p50" );
779 ADD_COMPRESSORNAME_TABLE( QT_CODEC_TYPE_ULRA_VIDEO
, "\017Ut Video (ULRA)" );
780 ADD_COMPRESSORNAME_TABLE( QT_CODEC_TYPE_ULRG_VIDEO
, "\017Ut Video (ULRG)" );
781 ADD_COMPRESSORNAME_TABLE( QT_CODEC_TYPE_ULY0_VIDEO
, "\017Ut Video (ULY0)" );
782 ADD_COMPRESSORNAME_TABLE( QT_CODEC_TYPE_ULY2_VIDEO
, "\017Ut Video (ULY2)" );
783 ADD_COMPRESSORNAME_TABLE( QT_CODEC_TYPE_ULH0_VIDEO
, "\017Ut Video (ULH0)" );
784 ADD_COMPRESSORNAME_TABLE( QT_CODEC_TYPE_ULH2_VIDEO
, "\017Ut Video (ULH2)" );
785 ADD_COMPRESSORNAME_TABLE( QT_CODEC_TYPE_UQY2_VIDEO
, "\021Ut Video Pro (UQY2)" );
786 ADD_COMPRESSORNAME_TABLE( LSMASH_CODEC_TYPE_UNSPECIFIED
, { '\0' } );
787 #undef ADD_COMPRESSORNAME_TABLE
789 for( int i
= 0; compressorname_table
[i
].name
[0] != '\0'; i
++ )
790 if( lsmash_check_codec_type_identical( sample_type
, compressorname_table
[i
].type
) )
792 strcpy( compressorname
, compressorname_table
[i
].name
);
797 lsmash_codec_specific_t
*isom_get_codec_specific( lsmash_codec_specific_list_t
*opaque
, lsmash_codec_specific_data_type type
)
799 for( lsmash_entry_t
*entry
= opaque
->list
.head
; entry
; entry
= entry
->next
)
801 lsmash_codec_specific_t
*specific
= (lsmash_codec_specific_t
*)entry
->data
;
802 if( !specific
|| specific
->type
!= type
)
809 static int isom_check_valid_summary( lsmash_summary_t
*summary
)
812 return LSMASH_ERR_NAMELESS
;
814 temp_box
.type
= summary
->sample_type
;
815 temp_box
.manager
= summary
->summary_type
== LSMASH_SUMMARY_TYPE_AUDIO
? LSMASH_AUDIO_DESCRIPTION
: 0;
816 if( isom_is_lpcm_audio( &temp_box
) )
818 if( isom_get_codec_specific( summary
->opaque
, LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_AUDIO_FORMAT_SPECIFIC_FLAGS
) )
820 return LSMASH_ERR_INVALID_DATA
;
822 if( isom_is_uncompressed_ycbcr( summary
->sample_type
) )
824 if( isom_get_codec_specific( summary
->opaque
, LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_VIDEO_FIELD_INFO
) )
826 if( !lsmash_check_codec_type_identical( summary
->sample_type
, QT_CODEC_TYPE_V216_VIDEO
) )
830 return LSMASH_ERR_INVALID_DATA
;
832 lsmash_codec_type_t sample_type
= summary
->sample_type
;
833 lsmash_codec_specific_data_type required_data_type
= LSMASH_CODEC_SPECIFIC_DATA_TYPE_UNSPECIFIED
;
834 if( lsmash_check_codec_type_identical( sample_type
, ISOM_CODEC_TYPE_AVC1_VIDEO
)
835 || lsmash_check_codec_type_identical( sample_type
, ISOM_CODEC_TYPE_AVC2_VIDEO
)
836 || lsmash_check_codec_type_identical( sample_type
, ISOM_CODEC_TYPE_AVC3_VIDEO
)
837 || lsmash_check_codec_type_identical( sample_type
, ISOM_CODEC_TYPE_AVC4_VIDEO
) )
838 required_data_type
= LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_VIDEO_H264
;
839 else if( lsmash_check_codec_type_identical( sample_type
, ISOM_CODEC_TYPE_HVC1_VIDEO
)
840 || lsmash_check_codec_type_identical( sample_type
, ISOM_CODEC_TYPE_HEV1_VIDEO
) )
841 required_data_type
= LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_VIDEO_HEVC
;
842 else if( lsmash_check_codec_type_identical( sample_type
, ISOM_CODEC_TYPE_VC_1_VIDEO
) )
843 required_data_type
= LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_VIDEO_VC_1
;
844 else if( lsmash_check_codec_type_identical( sample_type
, QT_CODEC_TYPE_ULRA_VIDEO
)
845 || lsmash_check_codec_type_identical( sample_type
, QT_CODEC_TYPE_ULRG_VIDEO
)
846 || lsmash_check_codec_type_identical( sample_type
, QT_CODEC_TYPE_ULY0_VIDEO
)
847 || lsmash_check_codec_type_identical( sample_type
, QT_CODEC_TYPE_ULY2_VIDEO
)
848 || lsmash_check_codec_type_identical( sample_type
, QT_CODEC_TYPE_ULH0_VIDEO
)
849 || lsmash_check_codec_type_identical( sample_type
, QT_CODEC_TYPE_ULH2_VIDEO
)
850 || lsmash_check_codec_type_identical( sample_type
, QT_CODEC_TYPE_UQY2_VIDEO
) )
851 required_data_type
= LSMASH_CODEC_SPECIFIC_DATA_TYPE_CODEC_GLOBAL_HEADER
;
852 else if( lsmash_check_codec_type_identical( sample_type
, QT_CODEC_TYPE_V216_VIDEO
) )
853 required_data_type
= LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_VIDEO_SIGNIFICANT_BITS
;
854 else if( lsmash_check_codec_type_identical( sample_type
, ISOM_CODEC_TYPE_MP4V_VIDEO
)
855 || lsmash_check_codec_type_identical( sample_type
, ISOM_CODEC_TYPE_MP4A_AUDIO
)
856 || lsmash_check_codec_type_identical( sample_type
, QT_CODEC_TYPE_MP4A_AUDIO
) )
857 required_data_type
= LSMASH_CODEC_SPECIFIC_DATA_TYPE_MP4SYS_DECODER_CONFIG
;
858 else if( lsmash_check_codec_type_identical( sample_type
, ISOM_CODEC_TYPE_AC_3_AUDIO
) )
859 required_data_type
= LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_AUDIO_AC_3
;
860 else if( lsmash_check_codec_type_identical( sample_type
, ISOM_CODEC_TYPE_EC_3_AUDIO
) )
861 required_data_type
= LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_AUDIO_EC_3
;
862 else if( lsmash_check_codec_type_identical( sample_type
, ISOM_CODEC_TYPE_DTSC_AUDIO
)
863 || lsmash_check_codec_type_identical( sample_type
, ISOM_CODEC_TYPE_DTSE_AUDIO
)
864 || lsmash_check_codec_type_identical( sample_type
, ISOM_CODEC_TYPE_DTSH_AUDIO
)
865 || lsmash_check_codec_type_identical( sample_type
, ISOM_CODEC_TYPE_DTSL_AUDIO
) )
866 required_data_type
= LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_AUDIO_DTS
;
867 else if( lsmash_check_codec_type_identical( sample_type
, ISOM_CODEC_TYPE_ALAC_AUDIO
)
868 || lsmash_check_codec_type_identical( sample_type
, QT_CODEC_TYPE_ALAC_AUDIO
) )
869 required_data_type
= LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_AUDIO_ALAC
;
870 if( required_data_type
== LSMASH_CODEC_SPECIFIC_DATA_TYPE_UNSPECIFIED
)
872 return isom_get_codec_specific( summary
->opaque
, required_data_type
) ? 0 : LSMASH_ERR_INVALID_DATA
;
875 static lsmash_box_type_t
isom_guess_video_codec_specific_box_type( lsmash_codec_type_t active_codec_type
, lsmash_compact_box_type_t fourcc
)
877 lsmash_box_type_t box_type
= LSMASH_BOX_TYPE_INITIALIZER
;
878 box_type
.fourcc
= fourcc
;
879 #define GUESS_VIDEO_CODEC_SPECIFIC_BOX_TYPE( codec_type, predefined_box_type ) \
880 else if( (codec_type.user.fourcc == 0 \
881 || lsmash_check_codec_type_identical( active_codec_type, codec_type )) \
882 && box_type.fourcc == predefined_box_type.fourcc ) \
883 box_type = predefined_box_type
885 GUESS_VIDEO_CODEC_SPECIFIC_BOX_TYPE( ISOM_CODEC_TYPE_AVC1_VIDEO
, ISOM_BOX_TYPE_AVCC
);
886 GUESS_VIDEO_CODEC_SPECIFIC_BOX_TYPE( ISOM_CODEC_TYPE_AVC2_VIDEO
, ISOM_BOX_TYPE_AVCC
);
887 GUESS_VIDEO_CODEC_SPECIFIC_BOX_TYPE( ISOM_CODEC_TYPE_AVC3_VIDEO
, ISOM_BOX_TYPE_AVCC
);
888 GUESS_VIDEO_CODEC_SPECIFIC_BOX_TYPE( ISOM_CODEC_TYPE_AVC4_VIDEO
, ISOM_BOX_TYPE_AVCC
);
889 GUESS_VIDEO_CODEC_SPECIFIC_BOX_TYPE( ISOM_CODEC_TYPE_AVCP_VIDEO
, ISOM_BOX_TYPE_AVCC
);
890 GUESS_VIDEO_CODEC_SPECIFIC_BOX_TYPE( ISOM_CODEC_TYPE_HVC1_VIDEO
, ISOM_BOX_TYPE_HVCC
);
891 GUESS_VIDEO_CODEC_SPECIFIC_BOX_TYPE( ISOM_CODEC_TYPE_HEV1_VIDEO
, ISOM_BOX_TYPE_HVCC
);
892 GUESS_VIDEO_CODEC_SPECIFIC_BOX_TYPE( ISOM_CODEC_TYPE_VC_1_VIDEO
, ISOM_BOX_TYPE_DVC1
);
893 GUESS_VIDEO_CODEC_SPECIFIC_BOX_TYPE( ISOM_CODEC_TYPE_MP4V_VIDEO
, ISOM_BOX_TYPE_ESDS
);
894 GUESS_VIDEO_CODEC_SPECIFIC_BOX_TYPE( LSMASH_CODEC_TYPE_UNSPECIFIED
, ISOM_BOX_TYPE_BTRT
);
895 GUESS_VIDEO_CODEC_SPECIFIC_BOX_TYPE( LSMASH_CODEC_TYPE_UNSPECIFIED
, QT_BOX_TYPE_FIEL
);
896 GUESS_VIDEO_CODEC_SPECIFIC_BOX_TYPE( LSMASH_CODEC_TYPE_UNSPECIFIED
, QT_BOX_TYPE_CSPC
);
897 GUESS_VIDEO_CODEC_SPECIFIC_BOX_TYPE( LSMASH_CODEC_TYPE_UNSPECIFIED
, QT_BOX_TYPE_SGBT
);
898 GUESS_VIDEO_CODEC_SPECIFIC_BOX_TYPE( LSMASH_CODEC_TYPE_UNSPECIFIED
, QT_BOX_TYPE_GAMA
);
899 GUESS_VIDEO_CODEC_SPECIFIC_BOX_TYPE( LSMASH_CODEC_TYPE_UNSPECIFIED
, QT_BOX_TYPE_GLBL
);
900 #undef GUESS_VIDEO_CODEC_SPECIFIC_BOX_TYPE
904 int isom_setup_visual_description( isom_stsd_t
*stsd
, lsmash_codec_type_t sample_type
, lsmash_video_summary_t
*summary
)
909 || !stsd
->parent
->parent
910 || !stsd
->parent
->parent
->parent
911 || !stsd
->parent
->parent
->parent
->parent
)
912 return LSMASH_ERR_NAMELESS
;
913 int err
= isom_check_valid_summary( (lsmash_summary_t
*)summary
);
916 isom_visual_entry_t
*visual
= isom_add_visual_description( stsd
, sample_type
);
918 return LSMASH_ERR_NAMELESS
;
919 visual
->data_reference_index
= summary
->data_ref_index
;
921 visual
->revision_level
= 0;
923 visual
->temporalQuality
= 0;
924 visual
->spatialQuality
= 0;
925 visual
->width
= (uint16_t)summary
->width
;
926 visual
->height
= (uint16_t)summary
->height
;
927 visual
->horizresolution
= 0x00480000;
928 visual
->vertresolution
= 0x00480000;
929 visual
->dataSize
= 0;
930 visual
->frame_count
= 1;
931 visual
->depth
= isom_is_qt_video( summary
->sample_type
) || isom_is_nalff( summary
->sample_type
)
932 ? summary
->depth
: 0x0018;
933 visual
->color_table_ID
= -1;
934 if( summary
->compressorname
[0] == '\0' )
935 isom_set_default_compressorname( visual
->compressorname
, sample_type
);
938 memcpy( visual
->compressorname
, summary
->compressorname
, 32 );
939 visual
->compressorname
[32] = '\0';
941 err
= LSMASH_ERR_NAMELESS
;
942 for( lsmash_entry_t
*entry
= summary
->opaque
->list
.head
; entry
; entry
= entry
->next
)
944 lsmash_codec_specific_t
*specific
= (lsmash_codec_specific_t
*)entry
->data
;
947 if( specific
->type
== LSMASH_CODEC_SPECIFIC_DATA_TYPE_UNKNOWN
948 && specific
->format
== LSMASH_CODEC_SPECIFIC_FORMAT_STRUCTURED
)
949 continue; /* LSMASH_CODEC_SPECIFIC_DATA_TYPE_UNKNOWN + LSMASH_CODEC_SPECIFIC_FORMAT_STRUCTURED is not supported. */
950 switch( specific
->type
)
952 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_VIDEO_COMMON
:
954 if( specific
->format
== LSMASH_CODEC_SPECIFIC_FORMAT_UNSTRUCTURED
)
956 lsmash_qt_video_common_t
*data
= (lsmash_qt_video_common_t
*)specific
->data
.structured
;
957 visual
->revision_level
= data
->revision_level
;
958 visual
->vendor
= data
->vendor
;
959 visual
->temporalQuality
= data
->temporalQuality
;
960 visual
->spatialQuality
= data
->spatialQuality
;
961 visual
->horizresolution
= data
->horizontal_resolution
;
962 visual
->vertresolution
= data
->vertical_resolution
;
963 visual
->dataSize
= data
->dataSize
;
964 visual
->frame_count
= data
->frame_count
;
965 visual
->color_table_ID
= data
->color_table_ID
;
966 if( data
->color_table_ID
== 0 )
968 lsmash_qt_color_table_t
*src_ct
= &data
->color_table
;
969 uint16_t element_count
= LSMASH_MIN( src_ct
->size
+ 1, 256 );
970 isom_qt_color_array_t
*dst_array
= lsmash_malloc_zero( element_count
* sizeof(isom_qt_color_array_t
) );
973 err
= LSMASH_ERR_MEMORY_ALLOC
;
976 isom_qt_color_table_t
*dst_ct
= &visual
->color_table
;
977 dst_ct
->array
= dst_array
;
978 dst_ct
->seed
= src_ct
->seed
;
979 dst_ct
->flags
= src_ct
->flags
;
980 dst_ct
->size
= src_ct
->size
;
981 for( uint16_t i
= 0; i
< element_count
; i
++ )
983 dst_array
[i
].value
= src_ct
->array
[i
].unused
;
984 dst_array
[i
].r
= src_ct
->array
[i
].r
;
985 dst_array
[i
].g
= src_ct
->array
[i
].g
;
986 dst_array
[i
].b
= src_ct
->array
[i
].b
;
991 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_VIDEO_SAMPLE_SCALE
:
993 lsmash_codec_specific_t
*cs
= lsmash_convert_codec_specific_format( specific
, LSMASH_CODEC_SPECIFIC_FORMAT_STRUCTURED
);
996 lsmash_isom_sample_scale_t
*data
= (lsmash_isom_sample_scale_t
*)cs
->data
.structured
;
997 isom_stsl_t
*stsl
= isom_add_stsl( visual
);
1000 lsmash_destroy_codec_specific_data( cs
);
1003 stsl
->constraint_flag
= data
->constraint_flag
;
1004 stsl
->scale_method
= data
->scale_method
;
1005 stsl
->display_center_x
= data
->display_center_x
;
1006 stsl
->display_center_y
= data
->display_center_y
;
1007 lsmash_destroy_codec_specific_data( cs
);
1010 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_VIDEO_H264_BITRATE
:
1012 lsmash_codec_specific_t
*cs
= lsmash_convert_codec_specific_format( specific
, LSMASH_CODEC_SPECIFIC_FORMAT_STRUCTURED
);
1015 lsmash_h264_bitrate_t
*data
= (lsmash_h264_bitrate_t
*)cs
->data
.structured
;
1016 isom_btrt_t
*btrt
= isom_add_btrt( visual
);
1019 lsmash_destroy_codec_specific_data( cs
);
1022 btrt
->bufferSizeDB
= data
->bufferSizeDB
;
1023 btrt
->maxBitrate
= data
->maxBitrate
;
1024 btrt
->avgBitrate
= data
->avgBitrate
;
1025 lsmash_destroy_codec_specific_data( cs
);
1028 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_VIDEO_FIELD_INFO
:
1030 lsmash_codec_specific_t
*cs
= lsmash_convert_codec_specific_format( specific
, LSMASH_CODEC_SPECIFIC_FORMAT_STRUCTURED
);
1033 lsmash_qt_field_info_t
*data
= (lsmash_qt_field_info_t
*)cs
->data
.structured
;
1034 isom_fiel_t
*fiel
= isom_add_fiel( visual
);
1037 lsmash_destroy_codec_specific_data( cs
);
1040 fiel
->fields
= data
->fields
;
1041 fiel
->detail
= data
->detail
;
1042 lsmash_destroy_codec_specific_data( cs
);
1045 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_VIDEO_PIXEL_FORMAT
:
1047 lsmash_codec_specific_t
*cs
= lsmash_convert_codec_specific_format( specific
, LSMASH_CODEC_SPECIFIC_FORMAT_STRUCTURED
);
1050 lsmash_qt_pixel_format_t
*data
= (lsmash_qt_pixel_format_t
*)cs
->data
.structured
;
1051 isom_cspc_t
*cspc
= isom_add_cspc( visual
);
1054 lsmash_destroy_codec_specific_data( cs
);
1057 cspc
->pixel_format
= data
->pixel_format
;
1058 lsmash_destroy_codec_specific_data( cs
);
1061 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_VIDEO_SIGNIFICANT_BITS
:
1063 lsmash_codec_specific_t
*cs
= lsmash_convert_codec_specific_format( specific
, LSMASH_CODEC_SPECIFIC_FORMAT_STRUCTURED
);
1066 lsmash_qt_significant_bits_t
*data
= (lsmash_qt_significant_bits_t
*)cs
->data
.structured
;
1067 isom_sgbt_t
*sgbt
= isom_add_sgbt( visual
);
1070 lsmash_destroy_codec_specific_data( cs
);
1073 sgbt
->significantBits
= data
->significantBits
;
1074 lsmash_destroy_codec_specific_data( cs
);
1077 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_VIDEO_GAMMA_LEVEL
:
1079 lsmash_codec_specific_t
*cs
= lsmash_convert_codec_specific_format( specific
, LSMASH_CODEC_SPECIFIC_FORMAT_STRUCTURED
);
1082 lsmash_qt_gamma_t
*data
= (lsmash_qt_gamma_t
*)cs
->data
.structured
;
1083 isom_gama_t
*gama
= isom_add_gama( visual
);
1086 lsmash_destroy_codec_specific_data( cs
);
1089 gama
->level
= data
->level
;
1090 lsmash_destroy_codec_specific_data( cs
);
1093 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_CODEC_GLOBAL_HEADER
:
1095 lsmash_codec_specific_t
*cs
= lsmash_convert_codec_specific_format( specific
, LSMASH_CODEC_SPECIFIC_FORMAT_STRUCTURED
);
1098 lsmash_codec_global_header_t
*data
= (lsmash_codec_global_header_t
*)cs
->data
.structured
;
1099 isom_glbl_t
*glbl
= isom_add_glbl( visual
);
1102 lsmash_destroy_codec_specific_data( cs
);
1105 glbl
->header_size
= data
->header_size
;
1106 glbl
->header_data
= lsmash_memdup( data
->header_data
, data
->header_size
);
1107 lsmash_destroy_codec_specific_data( cs
);
1108 if( !glbl
->header_data
)
1110 isom_remove_box_by_itself( glbl
);
1111 err
= LSMASH_ERR_MEMORY_ALLOC
;
1118 lsmash_codec_specific_t
*cs
= lsmash_convert_codec_specific_format( specific
, LSMASH_CODEC_SPECIFIC_FORMAT_UNSTRUCTURED
);
1121 if( cs
->size
< ISOM_BASEBOX_COMMON_SIZE
)
1123 lsmash_destroy_codec_specific_data( cs
);
1124 err
= LSMASH_ERR_INVALID_DATA
;
1127 uint8_t *data
= cs
->data
.unstructured
;
1128 lsmash_compact_box_type_t fourcc
= LSMASH_4CC( data
[4], data
[5], data
[6], data
[7] );
1129 lsmash_box_type_t box_type
= isom_guess_video_codec_specific_box_type( visual
->type
, fourcc
);
1130 /* Append the extension. */
1131 err
= isom_add_extension_binary( visual
, box_type
, LSMASH_BOX_PRECEDENCE_HM
, cs
->data
.unstructured
, cs
->size
);
1132 cs
->data
.unstructured
= NULL
; /* Avoid freeing the binary data of the extension. */
1133 lsmash_destroy_codec_specific_data( cs
);
1140 isom_trak_t
*trak
= (isom_trak_t
*)visual
->parent
->parent
->parent
->parent
->parent
;
1141 int qt_compatible
= trak
->file
->qt_compatible
;
1142 isom_tapt_t
*tapt
= trak
->tapt
;
1143 isom_stsl_t
*stsl
= (isom_stsl_t
*)isom_get_extension_box_format( &visual
->extensions
, ISOM_BOX_TYPE_STSL
);
1144 int set_aperture_modes
= qt_compatible
/* Track Aperture Modes is only available under QuickTime file format. */
1145 && (!stsl
|| stsl
->scale_method
== 0) /* Sample scaling method might conflict with this feature. */
1146 && tapt
&& tapt
->clef
&& tapt
->prof
&& tapt
->enof
/* Check if required boxes exist. */
1147 && ((isom_stsd_t
*)visual
->parent
)->list
.entry_count
== 1; /* Multiple sample description might conflict with this, so in that case, disable this feature. */
1148 if( !set_aperture_modes
)
1149 isom_remove_box_by_itself( trak
->tapt
);
1150 int uncompressed_ycbcr
= qt_compatible
&& isom_is_uncompressed_ycbcr( visual
->type
);
1151 /* Set up Clean Aperture. */
1152 if( set_aperture_modes
|| uncompressed_ycbcr
1153 || (summary
->clap
.width
.d
&& summary
->clap
.height
.d
&& summary
->clap
.horizontal_offset
.d
&& summary
->clap
.vertical_offset
.d
) )
1155 isom_clap_t
*clap
= isom_add_clap( visual
);
1158 if( summary
->clap
.width
.d
&& summary
->clap
.height
.d
&& summary
->clap
.horizontal_offset
.d
&& summary
->clap
.vertical_offset
.d
)
1160 clap
->cleanApertureWidthN
= summary
->clap
.width
.n
;
1161 clap
->cleanApertureWidthD
= summary
->clap
.width
.d
;
1162 clap
->cleanApertureHeightN
= summary
->clap
.height
.n
;
1163 clap
->cleanApertureHeightD
= summary
->clap
.height
.d
;
1164 clap
->horizOffN
= summary
->clap
.horizontal_offset
.n
;
1165 clap
->horizOffD
= summary
->clap
.horizontal_offset
.d
;
1166 clap
->vertOffN
= summary
->clap
.vertical_offset
.n
;
1167 clap
->vertOffD
= summary
->clap
.vertical_offset
.d
;
1171 clap
->cleanApertureWidthN
= summary
->width
;
1172 clap
->cleanApertureWidthD
= 1;
1173 clap
->cleanApertureHeightN
= summary
->height
;
1174 clap
->cleanApertureHeightD
= 1;
1175 clap
->horizOffN
= 0;
1176 clap
->horizOffD
= 1;
1181 /* Set up Pixel Aspect Ratio. */
1182 if( set_aperture_modes
|| (summary
->par_h
&& summary
->par_v
) )
1184 isom_pasp_t
*pasp
= isom_add_pasp( visual
);
1187 pasp
->hSpacing
= LSMASH_MAX( summary
->par_h
, 1 );
1188 pasp
->vSpacing
= LSMASH_MAX( summary
->par_v
, 1 );
1190 /* Set up Color Parameter. */
1191 if( uncompressed_ycbcr
1192 || summary
->color
.primaries_index
1193 || summary
->color
.transfer_index
1194 || summary
->color
.matrix_index
1195 || (trak
->file
->isom_compatible
&& summary
->color
.full_range
) )
1197 isom_colr_t
*colr
= isom_add_colr( visual
);
1200 /* Set 'nclc' to parameter type, we don't support 'prof'. */
1201 uint16_t primaries
= summary
->color
.primaries_index
;
1202 uint16_t transfer
= summary
->color
.transfer_index
;
1203 uint16_t matrix
= summary
->color
.matrix_index
;
1204 if( qt_compatible
&& !trak
->file
->isom_compatible
)
1206 colr
->manager
|= LSMASH_QTFF_BASE
;
1207 colr
->type
= QT_BOX_TYPE_COLR
;
1208 colr
->color_parameter_type
= QT_COLOR_PARAMETER_TYPE_NCLC
;
1209 colr
->primaries_index
= (primaries
== 1 || primaries
== 5 || primaries
== 6)
1210 ? primaries
: QT_PRIMARIES_INDEX_UNSPECIFIED
;
1211 colr
->transfer_function_index
= (transfer
== 1 || transfer
== 7)
1212 ? transfer
: QT_TRANSFER_INDEX_UNSPECIFIED
;
1213 colr
->matrix_index
= (matrix
== 1 || matrix
== 6 || matrix
== 7)
1214 ? matrix
: QT_MATRIX_INDEX_UNSPECIFIED
;
1218 colr
->type
= ISOM_BOX_TYPE_COLR
;
1219 colr
->color_parameter_type
= ISOM_COLOR_PARAMETER_TYPE_NCLX
;
1220 colr
->primaries_index
= (primaries
== 1 || (primaries
>= 4 && primaries
<= 7))
1221 ? primaries
: ISOM_PRIMARIES_INDEX_UNSPECIFIED
;
1222 colr
->transfer_function_index
= (transfer
== 1 || (transfer
>= 4 && transfer
<= 8) || (transfer
>= 11 && transfer
<= 13))
1223 ? transfer
: ISOM_TRANSFER_INDEX_UNSPECIFIED
;
1224 colr
->matrix_index
= (matrix
== 1 || (matrix
>= 4 && matrix
<= 8))
1225 ? matrix
: ISOM_MATRIX_INDEX_UNSPECIFIED
;
1226 colr
->full_range_flag
= summary
->color
.full_range
;
1229 /* Set up Track Apeture Modes. */
1230 if( set_aperture_modes
)
1232 uint32_t width
= visual
->width
<< 16;
1233 uint32_t height
= visual
->height
<< 16;
1234 isom_clap_t
*clap
= (isom_clap_t
*)isom_get_extension_box_format( &visual
->extensions
, ISOM_BOX_TYPE_CLAP
);
1235 isom_pasp_t
*pasp
= (isom_pasp_t
*)isom_get_extension_box_format( &visual
->extensions
, ISOM_BOX_TYPE_PASP
);
1236 double clap_width
= ((double)clap
->cleanApertureWidthN
/ clap
->cleanApertureWidthD
) * (1<<16);
1237 double clap_height
= ((double)clap
->cleanApertureHeightN
/ clap
->cleanApertureHeightD
) * (1<<16);
1238 double par
= (double)pasp
->hSpacing
/ pasp
->vSpacing
;
1241 tapt
->clef
->width
= clap_width
* par
;
1242 tapt
->clef
->height
= clap_height
;
1243 tapt
->prof
->width
= width
* par
;
1244 tapt
->prof
->height
= height
;
1248 tapt
->clef
->width
= clap_width
;
1249 tapt
->clef
->height
= clap_height
/ par
;
1250 tapt
->prof
->width
= width
;
1251 tapt
->prof
->height
= height
/ par
;
1253 tapt
->enof
->width
= width
;
1254 tapt
->enof
->height
= height
;
1258 isom_remove_box_by_itself( visual
);
1262 static int isom_append_audio_es_descriptor_extension( isom_box_t
*box
, lsmash_audio_summary_t
*summary
)
1264 uint32_t esds_size
= 0;
1265 uint8_t *esds_data
= NULL
;
1266 lsmash_codec_specific_t
*specific
= isom_get_codec_specific( summary
->opaque
, LSMASH_CODEC_SPECIFIC_DATA_TYPE_MP4SYS_DECODER_CONFIG
);
1268 return LSMASH_ERR_NAMELESS
;
1269 if( specific
->format
== LSMASH_CODEC_SPECIFIC_FORMAT_UNSTRUCTURED
)
1271 esds_size
= specific
->size
;
1272 esds_data
= lsmash_memdup( specific
->data
.unstructured
, specific
->size
);
1274 return LSMASH_ERR_MEMORY_ALLOC
;
1278 esds_data
= lsmash_create_mp4sys_decoder_config( (lsmash_mp4sys_decoder_parameters_t
*)specific
->data
.structured
, &esds_size
);
1280 return LSMASH_ERR_NAMELESS
;
1282 isom_esds_t
*esds
= isom_add_esds( box
);
1285 lsmash_free( esds_data
);
1286 return LSMASH_ERR_NAMELESS
;
1288 lsmash_bs_t bs
= { 0 };
1289 bs
.buffer
.data
= esds_data
+ ISOM_FULLBOX_COMMON_SIZE
;
1290 bs
.buffer
.alloc
= esds_size
- ISOM_FULLBOX_COMMON_SIZE
;
1291 bs
.buffer
.store
= bs
.buffer
.alloc
;
1292 esds
->ES
= mp4sys_get_descriptor( &bs
, NULL
);
1293 lsmash_free( esds_data
);
1296 isom_remove_box_by_itself( esds
);
1297 return LSMASH_ERR_NAMELESS
;
1302 static int isom_append_channel_layout_extension( lsmash_codec_specific_t
*specific
, void *parent
, uint32_t channels
)
1305 if( isom_get_extension_box( &((isom_box_t
*)parent
)->extensions
, QT_BOX_TYPE_CHAN
) )
1306 return 0; /* Audio Channel Layout Box is already present. */
1307 lsmash_codec_specific_t
*cs
= lsmash_convert_codec_specific_format( specific
, LSMASH_CODEC_SPECIFIC_FORMAT_STRUCTURED
);
1309 return LSMASH_ERR_NAMELESS
;
1310 lsmash_qt_audio_channel_layout_t
*data
= (lsmash_qt_audio_channel_layout_t
*)cs
->data
.structured
;
1311 lsmash_channel_layout_tag channelLayoutTag
= data
->channelLayoutTag
;
1312 lsmash_channel_bitmap channelBitmap
= data
->channelBitmap
;
1313 if( channelLayoutTag
== QT_CHANNEL_LAYOUT_USE_CHANNEL_DESCRIPTIONS
/* We don't support the feature of Channel Descriptions. */
1314 || (channelLayoutTag
== QT_CHANNEL_LAYOUT_USE_CHANNEL_BITMAP
&& (!channelBitmap
|| channelBitmap
> QT_CHANNEL_BIT_FULL
)) )
1316 channelLayoutTag
= QT_CHANNEL_LAYOUT_UNKNOWN
| channels
;
1319 lsmash_destroy_codec_specific_data( cs
);
1320 /* Don't create Audio Channel Layout Box if the channel layout is unknown. */
1321 if( (channelLayoutTag
^ QT_CHANNEL_LAYOUT_UNKNOWN
) >> 16 )
1323 isom_chan_t
*chan
= isom_add_chan( parent
);
1325 return LSMASH_ERR_NAMELESS
;
1326 chan
->channelLayoutTag
= channelLayoutTag
;
1327 chan
->channelBitmap
= channelBitmap
;
1328 chan
->numberChannelDescriptions
= 0;
1329 chan
->channelDescriptions
= NULL
;
1334 static int isom_set_qtff_mp4a_description( isom_audio_entry_t
*audio
, lsmash_audio_summary_t
*summary
)
1336 isom_wave_t
*wave
= isom_add_wave( audio
);
1338 if( !(frma
= isom_add_frma( wave
))
1339 || !isom_add_mp4a( wave
)
1340 || !isom_add_terminator( wave
) )
1342 lsmash_remove_entry_tail( &audio
->extensions
, wave
->destruct
);
1343 return LSMASH_ERR_NAMELESS
;
1345 frma
->data_format
= audio
->type
.fourcc
;
1346 /* Add ES Descriptor Box. */
1347 int err
= isom_append_audio_es_descriptor_extension( (isom_box_t
*)wave
, summary
);
1351 audio
->type
= QT_CODEC_TYPE_MP4A_AUDIO
;
1352 audio
->version
= (summary
->channels
> 2 || summary
->frequency
> UINT16_MAX
) ? 2 : 1;
1353 audio
->channelcount
= audio
->version
== 2 ? 3 : LSMASH_MIN( summary
->channels
, 2 );
1354 audio
->samplesize
= 16;
1355 audio
->compression_ID
= QT_AUDIO_COMPRESSION_ID_VARIABLE_COMPRESSION
;
1356 audio
->packet_size
= 0;
1357 if( audio
->version
== 1 )
1359 audio
->samplerate
= summary
->frequency
<< 16;
1360 audio
->samplesPerPacket
= summary
->samples_in_frame
;
1361 audio
->bytesPerPacket
= 1; /* Apparently, this field is set to 1. */
1362 audio
->bytesPerFrame
= audio
->bytesPerPacket
* summary
->channels
;
1363 audio
->bytesPerSample
= 2;
1365 else /* audio->version == 2 */
1367 audio
->samplerate
= 0x00010000;
1368 audio
->sizeOfStructOnly
= 72;
1369 audio
->audioSampleRate
= (union {double d
; uint64_t i
;}){summary
->frequency
}.i
;
1370 audio
->numAudioChannels
= summary
->channels
;
1371 audio
->always7F000000
= 0x7F000000;
1372 audio
->constBitsPerChannel
= 0; /* compressed audio */
1373 audio
->formatSpecificFlags
= 0;
1374 audio
->constBytesPerAudioPacket
= 0; /* variable */
1375 audio
->constLPCMFramesPerAudioPacket
= summary
->samples_in_frame
;
1380 static int isom_set_isom_mp4a_description( isom_audio_entry_t
*audio
, lsmash_audio_summary_t
*summary
)
1382 if( summary
->summary_type
!= LSMASH_SUMMARY_TYPE_AUDIO
)
1383 return LSMASH_ERR_NAMELESS
;
1384 /* Check objectTypeIndication. */
1385 lsmash_mp4sys_object_type_indication objectTypeIndication
= lsmash_mp4sys_get_object_type_indication( (lsmash_summary_t
*)summary
);
1386 switch( objectTypeIndication
)
1388 case MP4SYS_OBJECT_TYPE_Audio_ISO_14496_3
:
1389 case MP4SYS_OBJECT_TYPE_Audio_ISO_13818_7_Main_Profile
:
1390 case MP4SYS_OBJECT_TYPE_Audio_ISO_13818_7_LC_Profile
:
1391 case MP4SYS_OBJECT_TYPE_Audio_ISO_13818_7_SSR_Profile
:
1392 case MP4SYS_OBJECT_TYPE_Audio_ISO_13818_3
: /* Legacy Interface */
1393 case MP4SYS_OBJECT_TYPE_Audio_ISO_11172_3
: /* Legacy Interface */
1396 return LSMASH_ERR_NAMELESS
;
1398 /* Add ES Descriptor Box. */
1399 int err
= isom_append_audio_es_descriptor_extension( (isom_box_t
*)audio
, summary
);
1402 /* In pure mp4 file, these "template" fields shall be default values according to the spec.
1403 But not pure - hybrid with other spec - mp4 file can take other values.
1404 Which is to say, these template values shall be ignored in terms of mp4, except some object_type_indications.
1405 see 14496-14, "Template fields used". */
1406 audio
->type
= ISOM_CODEC_TYPE_MP4A_AUDIO
;
1408 audio
->revision_level
= 0;
1410 audio
->channelcount
= 2;
1411 audio
->samplesize
= 16;
1412 audio
->compression_ID
= 0;
1413 audio
->packet_size
= 0;
1414 /* WARNING: This field cannot retain frequency above 65535Hz.
1415 This is not "FIXME", I just honestly implemented what the spec says.
1416 BTW, who ever expects sampling frequency takes fixed-point decimal??? */
1417 audio
->samplerate
= summary
->frequency
<= UINT16_MAX
? summary
->frequency
<< 16 : 0;
1421 static int isom_set_qtff_lpcm_description( isom_audio_entry_t
*audio
, lsmash_audio_summary_t
*summary
)
1423 lsmash_qt_audio_format_specific_flags_t
*lpcm
= NULL
;
1424 for( lsmash_entry_t
*entry
= summary
->opaque
->list
.head
; entry
; entry
= entry
->next
)
1426 lsmash_codec_specific_t
*specific
= (lsmash_codec_specific_t
*)entry
->data
;
1429 if( specific
->type
== LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_AUDIO_FORMAT_SPECIFIC_FLAGS
1430 && specific
->format
== LSMASH_CODEC_SPECIFIC_FORMAT_STRUCTURED
)
1432 lpcm
= (lsmash_qt_audio_format_specific_flags_t
*)specific
->data
.structured
;
1437 return LSMASH_ERR_NAMELESS
;
1438 audio
->manager
|= LSMASH_QTFF_BASE
;
1439 lsmash_codec_type_t sample_type
= audio
->type
;
1440 /* Convert the sample type into 'lpcm' if the description doesn't match the format or version = 2 fields are needed. */
1441 if( (lsmash_check_codec_type_identical( sample_type
, QT_CODEC_TYPE_RAW_AUDIO
)
1442 && (summary
->sample_size
!= 8 || (lpcm
->format_flags
& QT_LPCM_FORMAT_FLAG_FLOAT
)))
1443 || (lsmash_check_codec_type_identical( sample_type
, QT_CODEC_TYPE_FL32_AUDIO
)
1444 && (summary
->sample_size
!= 32 || !(lpcm
->format_flags
& QT_LPCM_FORMAT_FLAG_FLOAT
)))
1445 || (lsmash_check_codec_type_identical( sample_type
, QT_CODEC_TYPE_FL64_AUDIO
)
1446 && (summary
->sample_size
!= 64 || !(lpcm
->format_flags
& QT_LPCM_FORMAT_FLAG_FLOAT
)))
1447 || (lsmash_check_codec_type_identical( sample_type
, QT_CODEC_TYPE_IN24_AUDIO
)
1448 && (summary
->sample_size
!= 24 || (lpcm
->format_flags
& QT_LPCM_FORMAT_FLAG_FLOAT
)))
1449 || (lsmash_check_codec_type_identical( sample_type
, QT_CODEC_TYPE_IN32_AUDIO
)
1450 && (summary
->sample_size
!= 32 || (lpcm
->format_flags
& QT_LPCM_FORMAT_FLAG_FLOAT
)))
1451 || (lsmash_check_codec_type_identical( sample_type
, QT_CODEC_TYPE_23NI_AUDIO
)
1452 && (summary
->sample_size
!= 32 || (lpcm
->format_flags
& QT_LPCM_FORMAT_FLAG_FLOAT
) || (lpcm
->format_flags
& QT_LPCM_FORMAT_FLAG_BIG_ENDIAN
)))
1453 || (lsmash_check_codec_type_identical( sample_type
, QT_CODEC_TYPE_SOWT_AUDIO
)
1454 && (summary
->sample_size
!= 16 || (lpcm
->format_flags
& QT_LPCM_FORMAT_FLAG_FLOAT
) || (lpcm
->format_flags
& QT_LPCM_FORMAT_FLAG_BIG_ENDIAN
)))
1455 || (lsmash_check_codec_type_identical( sample_type
, QT_CODEC_TYPE_TWOS_AUDIO
)
1456 && ((summary
->sample_size
!= 16 && summary
->sample_size
!= 8) || (lpcm
->format_flags
& QT_LPCM_FORMAT_FLAG_FLOAT
) || !(lpcm
->format_flags
& QT_LPCM_FORMAT_FLAG_BIG_ENDIAN
)))
1457 || (lsmash_check_codec_type_identical( sample_type
, QT_CODEC_TYPE_NONE_AUDIO
)
1458 && ((summary
->sample_size
!= 16 && summary
->sample_size
!= 8) || (lpcm
->format_flags
& QT_LPCM_FORMAT_FLAG_FLOAT
) || !(lpcm
->format_flags
& QT_LPCM_FORMAT_FLAG_BIG_ENDIAN
)))
1459 || (lsmash_check_codec_type_identical( sample_type
, QT_CODEC_TYPE_NOT_SPECIFIED
)
1460 && ((summary
->sample_size
!= 16 && summary
->sample_size
!= 8) || (lpcm
->format_flags
& QT_LPCM_FORMAT_FLAG_FLOAT
) || !(lpcm
->format_flags
& QT_LPCM_FORMAT_FLAG_BIG_ENDIAN
)))
1461 || (summary
->channels
> 2 || summary
->frequency
> UINT16_MAX
|| summary
->sample_size
% 8) )
1463 audio
->type
= QT_CODEC_TYPE_LPCM_AUDIO
;
1466 else if( lsmash_check_codec_type_identical( sample_type
, QT_CODEC_TYPE_LPCM_AUDIO
) )
1468 else if( summary
->sample_size
> 16
1469 || (!lsmash_check_codec_type_identical( sample_type
, QT_CODEC_TYPE_RAW_AUDIO
)
1470 && !lsmash_check_codec_type_identical( sample_type
, QT_CODEC_TYPE_TWOS_AUDIO
)
1471 && !lsmash_check_codec_type_identical( sample_type
, QT_CODEC_TYPE_NONE_AUDIO
)
1472 && !lsmash_check_codec_type_identical( sample_type
, QT_CODEC_TYPE_NOT_SPECIFIED
)) )
1474 /* Set up constBytesPerAudioPacket field.
1475 * We use constBytesPerAudioPacket as the actual size of LPCM audio frame even when version is not 2. */
1476 audio
->constBytesPerAudioPacket
= (summary
->sample_size
* summary
->channels
) / 8;
1477 /* Set up other fields in this description by its version. */
1478 if( audio
->version
== 2 )
1480 audio
->channelcount
= 3;
1481 audio
->samplesize
= 16;
1482 audio
->compression_ID
= -2;
1483 audio
->samplerate
= 0x00010000;
1484 audio
->sizeOfStructOnly
= 72;
1485 audio
->audioSampleRate
= (union {double d
; uint64_t i
;}){summary
->frequency
}.i
;
1486 audio
->numAudioChannels
= summary
->channels
;
1487 audio
->always7F000000
= 0x7F000000;
1488 audio
->constBitsPerChannel
= summary
->sample_size
;
1489 audio
->constLPCMFramesPerAudioPacket
= 1;
1490 audio
->formatSpecificFlags
= lpcm
->format_flags
;
1491 if( lsmash_check_codec_type_identical( sample_type
, QT_CODEC_TYPE_TWOS_AUDIO
) && summary
->sample_size
!= 8 )
1492 audio
->formatSpecificFlags
|= QT_LPCM_FORMAT_FLAG_BIG_ENDIAN
;
1493 if( lpcm
->format_flags
& QT_LPCM_FORMAT_FLAG_FLOAT
)
1494 audio
->formatSpecificFlags
&= ~QT_LPCM_FORMAT_FLAG_SIGNED_INTEGER
;
1495 if( lpcm
->format_flags
& QT_LPCM_FORMAT_FLAG_PACKED
)
1496 audio
->formatSpecificFlags
&= ~QT_LPCM_FORMAT_FLAG_ALIGNED_HIGH
;
1498 else if( audio
->version
== 1 )
1500 audio
->channelcount
= summary
->channels
;
1501 audio
->samplesize
= 16;
1502 /* Audio formats other than 'raw ' and 'twos' are treated as compressed audio. */
1503 if( lsmash_check_codec_type_identical( sample_type
, QT_CODEC_TYPE_RAW_AUDIO
)
1504 || lsmash_check_codec_type_identical( sample_type
, QT_CODEC_TYPE_TWOS_AUDIO
) )
1505 audio
->compression_ID
= QT_AUDIO_COMPRESSION_ID_NOT_COMPRESSED
;
1507 audio
->compression_ID
= QT_AUDIO_COMPRESSION_ID_FIXED_COMPRESSION
;
1508 audio
->samplerate
= summary
->frequency
<< 16;
1509 audio
->samplesPerPacket
= 1;
1510 audio
->bytesPerPacket
= summary
->sample_size
/ 8;
1511 audio
->bytesPerFrame
= audio
->bytesPerPacket
* summary
->channels
; /* sample_size field in stsz box is NOT used. */
1512 audio
->bytesPerSample
= 1 + (summary
->sample_size
!= 8);
1513 if( lsmash_check_codec_type_identical( sample_type
, QT_CODEC_TYPE_FL32_AUDIO
)
1514 || lsmash_check_codec_type_identical( sample_type
, QT_CODEC_TYPE_FL64_AUDIO
)
1515 || lsmash_check_codec_type_identical( sample_type
, QT_CODEC_TYPE_IN24_AUDIO
)
1516 || lsmash_check_codec_type_identical( sample_type
, QT_CODEC_TYPE_IN32_AUDIO
) )
1518 isom_wave_t
*wave
= isom_add_wave( audio
);
1521 if( !(frma
= isom_add_frma( wave
))
1522 || !(enda
= isom_add_enda( wave
))
1523 || !isom_add_terminator( wave
) )
1525 lsmash_remove_entry_tail( &audio
->extensions
, wave
->destruct
);
1526 return LSMASH_ERR_NAMELESS
;
1528 frma
->data_format
= sample_type
.fourcc
;
1529 enda
->littleEndian
= !(lpcm
->format_flags
& QT_LPCM_FORMAT_FLAG_BIG_ENDIAN
);
1532 else /* audio->version == 0 */
1534 audio
->channelcount
= summary
->channels
;
1535 audio
->samplesize
= summary
->sample_size
;
1536 audio
->compression_ID
= QT_AUDIO_COMPRESSION_ID_NOT_COMPRESSED
;
1537 audio
->samplerate
= summary
->frequency
<< 16;
1542 static int isom_set_isom_dts_description( isom_audio_entry_t
*audio
, lsmash_audio_summary_t
*summary
)
1545 audio
->revision_level
= 0;
1547 audio
->channelcount
= summary
->channels
;
1548 audio
->samplesize
= 16;
1549 audio
->compression_ID
= 0;
1550 audio
->packet_size
= 0;
1551 switch( summary
->frequency
)
1553 case 12000 : /* Invalid? (No reference in the spec) */
1558 case 384000 : /* Invalid? (No reference in the spec) */
1559 audio
->samplerate
= 48000 << 16;
1565 case 352800 : /* Invalid? (No reference in the spec) */
1566 audio
->samplerate
= 44100 << 16;
1568 case 8000 : /* Invalid? (No reference in the spec) */
1573 audio
->samplerate
= 32000 << 16;
1576 audio
->samplerate
= 0;
1582 static lsmash_box_type_t
isom_guess_audio_codec_specific_box_type( lsmash_codec_type_t active_codec_type
, lsmash_compact_box_type_t fourcc
)
1584 lsmash_box_type_t box_type
= LSMASH_BOX_TYPE_INITIALIZER
;
1585 box_type
.fourcc
= fourcc
;
1586 #define GUESS_AUDIO_CODEC_SPECIFIC_BOX_TYPE( codec_type, predefined_box_type ) \
1587 else if( (codec_type.user.fourcc == 0 \
1588 || lsmash_check_codec_type_identical( active_codec_type, codec_type )) \
1589 && box_type.fourcc == predefined_box_type.fourcc ) \
1590 box_type = predefined_box_type
1592 GUESS_AUDIO_CODEC_SPECIFIC_BOX_TYPE( ISOM_CODEC_TYPE_AC_3_AUDIO
, ISOM_BOX_TYPE_DAC3
);
1593 GUESS_AUDIO_CODEC_SPECIFIC_BOX_TYPE( ISOM_CODEC_TYPE_EC_3_AUDIO
, ISOM_BOX_TYPE_DEC3
);
1594 GUESS_AUDIO_CODEC_SPECIFIC_BOX_TYPE( ISOM_CODEC_TYPE_DTSC_AUDIO
, ISOM_BOX_TYPE_DDTS
);
1595 GUESS_AUDIO_CODEC_SPECIFIC_BOX_TYPE( ISOM_CODEC_TYPE_DTSE_AUDIO
, ISOM_BOX_TYPE_DDTS
);
1596 GUESS_AUDIO_CODEC_SPECIFIC_BOX_TYPE( ISOM_CODEC_TYPE_DTSH_AUDIO
, ISOM_BOX_TYPE_DDTS
);
1597 GUESS_AUDIO_CODEC_SPECIFIC_BOX_TYPE( ISOM_CODEC_TYPE_DTSL_AUDIO
, ISOM_BOX_TYPE_DDTS
);
1598 GUESS_AUDIO_CODEC_SPECIFIC_BOX_TYPE( ISOM_CODEC_TYPE_ALAC_AUDIO
, ISOM_BOX_TYPE_ALAC
);
1599 GUESS_AUDIO_CODEC_SPECIFIC_BOX_TYPE( ISOM_CODEC_TYPE_MP4A_AUDIO
, ISOM_BOX_TYPE_ESDS
);
1600 GUESS_AUDIO_CODEC_SPECIFIC_BOX_TYPE( QT_CODEC_TYPE_ALAC_AUDIO
, QT_BOX_TYPE_ALAC
);
1601 GUESS_AUDIO_CODEC_SPECIFIC_BOX_TYPE( QT_CODEC_TYPE_MP4A_AUDIO
, QT_BOX_TYPE_ESDS
);
1602 GUESS_AUDIO_CODEC_SPECIFIC_BOX_TYPE( QT_CODEC_TYPE_FULLMP3_AUDIO
, QT_CODEC_TYPE_MP3_AUDIO
);
1603 GUESS_AUDIO_CODEC_SPECIFIC_BOX_TYPE( QT_CODEC_TYPE_ADPCM2_AUDIO
, QT_CODEC_TYPE_ADPCM2_AUDIO
);
1604 GUESS_AUDIO_CODEC_SPECIFIC_BOX_TYPE( QT_CODEC_TYPE_ADPCM17_AUDIO
, QT_CODEC_TYPE_ADPCM17_AUDIO
);
1605 GUESS_AUDIO_CODEC_SPECIFIC_BOX_TYPE( QT_CODEC_TYPE_GSM49_AUDIO
, QT_CODEC_TYPE_GSM49_AUDIO
);
1606 GUESS_AUDIO_CODEC_SPECIFIC_BOX_TYPE( LSMASH_CODEC_TYPE_UNSPECIFIED
, QT_BOX_TYPE_CHAN
);
1607 GUESS_AUDIO_CODEC_SPECIFIC_BOX_TYPE( LSMASH_CODEC_TYPE_UNSPECIFIED
, QT_BOX_TYPE_GLBL
);
1608 GUESS_AUDIO_CODEC_SPECIFIC_BOX_TYPE( LSMASH_CODEC_TYPE_UNSPECIFIED
, QT_BOX_TYPE_WAVE
);
1609 #undef GUESS_AUDIO_CODEC_SPECIFIC_BOX_TYPE
1615 uint16_t wFormatTag
;
1617 uint32_t nSamplesPerSec
;
1618 uint32_t nAvgBytesPerSec
;
1619 uint16_t nBlockAlign
;
1620 uint16_t wBitsPerSample
;
1624 static lsmash_bs_t
*isom_create_waveform_audio_info
1626 wave_format_ex_t
*wfx
,
1627 lsmash_box_type_t type
1630 lsmash_bs_t
*bs
= lsmash_bs_create();
1633 lsmash_bs_put_be32( bs
, ISOM_BASEBOX_COMMON_SIZE
+ 18 + wfx
->cbSize
);
1634 lsmash_bs_put_be32( bs
, type
.fourcc
);
1635 lsmash_bs_put_le16( bs
, wfx
->wFormatTag
);
1636 lsmash_bs_put_le16( bs
, wfx
->nChannels
);
1637 lsmash_bs_put_le32( bs
, wfx
->nSamplesPerSec
);
1638 lsmash_bs_put_le32( bs
, wfx
->nAvgBytesPerSec
);
1639 lsmash_bs_put_le16( bs
, wfx
->nBlockAlign
);
1640 lsmash_bs_put_le16( bs
, wfx
->wBitsPerSample
);
1641 lsmash_bs_put_le16( bs
, wfx
->cbSize
);
1645 static int isom_setup_waveform_audio_info
1648 isom_audio_entry_t
*audio
,
1649 lsmash_audio_summary_t
*summary
,
1650 uint32_t samples_per_packet
,
1651 uint32_t bytes_per_frame
,
1652 uint32_t sample_size
1655 wave_format_ex_t wfx
;
1656 wfx
.wFormatTag
= 0x0000; /* WAVE_FORMAT_UNKNOWN */
1657 wfx
.nChannels
= summary
->channels
;
1658 wfx
.nSamplesPerSec
= summary
->frequency
;
1659 wfx
.nAvgBytesPerSec
= 0;
1660 wfx
.nBlockAlign
= bytes_per_frame
;
1661 wfx
.wBitsPerSample
= sample_size
;
1663 lsmash_bs_t
*bs
= NULL
;
1664 if( lsmash_check_codec_type_identical( audio
->type
, QT_CODEC_TYPE_ADPCM2_AUDIO
) )
1666 /* ADPCMWAVEFORMAT */
1667 wfx
.wFormatTag
= 0x0002; /* WAVE_FORMAT_ADPCM */
1669 bs
= isom_create_waveform_audio_info( &wfx
, audio
->type
);
1671 return LSMASH_ERR_MEMORY_ALLOC
;
1672 uint16_t wSamplesPerBlock
= samples_per_packet
; /* nBlockAlign * 2 / nChannels - 12 */
1673 uint16_t wNumCoef
= 7; /* Microsoft ADPCM uses just 7 coefficients. */
1678 } aCoef
[7] = { { 256, 0 }, { 512, -256 }, { 0,0 }, { 192,64 }, { 240,0 }, { 460, -208 }, { 392,-232 } };
1679 lsmash_bs_put_le16( bs
, wSamplesPerBlock
);
1680 lsmash_bs_put_le16( bs
, wNumCoef
);
1681 for( int i
= 0; i
< 7; i
++ )
1683 lsmash_bs_put_le16( bs
, aCoef
[i
].iCoef1
);
1684 lsmash_bs_put_le16( bs
, aCoef
[i
].iCoef2
);
1687 else if( lsmash_check_codec_type_identical( audio
->type
, QT_CODEC_TYPE_ADPCM17_AUDIO
) )
1689 /* IMAADPCMWAVEFORMAT */
1690 wfx
.wFormatTag
= 0x0011; /* WAVE_FORMAT_DVI_ADPCM / WAVE_FORMAT_IMA_ADPCM */
1692 bs
= isom_create_waveform_audio_info( &wfx
, audio
->type
);
1694 return LSMASH_ERR_MEMORY_ALLOC
;
1695 uint16_t wSamplesPerBlock
= samples_per_packet
;
1696 lsmash_bs_put_le16( bs
, wSamplesPerBlock
);
1698 else if( lsmash_check_codec_type_identical( audio
->type
, QT_CODEC_TYPE_GSM49_AUDIO
) )
1700 /* GSM610WAVEFORMAT */
1701 wfx
.wFormatTag
= 0x0031; /* WAVE_FORMAT_GSM610 */
1703 bs
= isom_create_waveform_audio_info( &wfx
, audio
->type
);
1705 return LSMASH_ERR_MEMORY_ALLOC
;
1706 uint16_t wSamplesPerBlock
= samples_per_packet
;
1707 lsmash_bs_put_le16( bs
, wSamplesPerBlock
);
1709 else if( lsmash_check_codec_type_identical( audio
->type
, QT_CODEC_TYPE_FULLMP3_AUDIO
)
1710 || lsmash_check_codec_type_identical( audio
->type
, QT_CODEC_TYPE_MP3_AUDIO
) )
1712 /* MPEGLAYER3WAVEFORMAT */
1713 wfx
.wFormatTag
= 0x0055; /* WAVE_FORMAT_MPEGLAYER3 */
1714 wfx
.nBlockAlign
= 1; /* ? */
1715 wfx
.wBitsPerSample
= 0; /* undefined */
1717 bs
= isom_create_waveform_audio_info( &wfx
, audio
->type
);
1719 return LSMASH_ERR_MEMORY_ALLOC
;
1720 uint16_t wID
= 1; /* MPEGLAYER3_ID_MPEG */
1721 uint32_t fdwFlags
= 0; /* We don't know whether the stream is padded or not here. */
1722 uint16_t nBlockSize
= 0; /* (144 * (bitrate / nSamplesPerSec) + padding) * nFramesPerBlock */
1723 uint16_t nFramesPerBlock
= 1; /* the number of audio frames per block */
1724 uint16_t nCodecDelay
= 0; /* Encoder delay in samples is unknown. */
1725 lsmash_bs_put_le16( bs
, wID
);
1726 lsmash_bs_put_le32( bs
, fdwFlags
);
1727 lsmash_bs_put_le16( bs
, nBlockSize
);
1728 lsmash_bs_put_le16( bs
, nFramesPerBlock
);
1729 lsmash_bs_put_le16( bs
, nCodecDelay
);
1734 return LSMASH_ERR_NAMELESS
;
1737 uint8_t *wfx_data
= lsmash_bs_export_data( bs
, &wfx_size
);
1738 lsmash_bs_cleanup( bs
);
1740 return LSMASH_ERR_NAMELESS
;
1741 if( wfx_size
!= ISOM_BASEBOX_COMMON_SIZE
+ 18 + wfx
.cbSize
)
1743 lsmash_free( wfx_data
);
1744 return LSMASH_ERR_NAMELESS
;
1746 int err
= isom_add_extension_binary( wave
, audio
->type
, LSMASH_BOX_PRECEDENCE_HM
, wfx_data
, wfx_size
);
1749 lsmash_free( wfx_data
);
1755 static int isom_set_qtff_sound_decompression_parameters
1757 isom_audio_entry_t
*audio
,
1758 lsmash_audio_summary_t
*summary
,
1759 lsmash_qt_audio_format_specific_flag
*format_flags
,
1760 uint32_t samples_per_packet
,
1761 uint32_t bytes_per_frame
,
1762 uint32_t sample_size
1765 /* A 'wave' extension itself shall be absent in the opaque CODEC specific info list.
1766 * So, create a 'wave' extension here and append it as an extension to the audio sample description. */
1767 isom_wave_t
*wave
= isom_add_wave( audio
);
1768 if( !isom_add_frma ( wave
)
1769 || !isom_add_terminator( wave
) )
1771 lsmash_remove_entry_tail( &audio
->extensions
, wave
->destruct
);
1772 return LSMASH_ERR_NAMELESS
;
1774 wave
->frma
->data_format
= audio
->type
.fourcc
;
1775 /* Append extensions from the opaque CODEC specific info list to 'wave' extension. */
1777 int waveform_audio_info_present
= 0;
1778 int requires_waveform_audio_info
= isom_is_waveform_audio( audio
->type
);
1779 for( lsmash_entry_t
*entry
= summary
->opaque
->list
.head
; entry
; entry
= entry
->next
)
1781 lsmash_codec_specific_t
*specific
= (lsmash_codec_specific_t
*)entry
->data
;
1783 return LSMASH_ERR_NAMELESS
;
1784 if( specific
->type
== LSMASH_CODEC_SPECIFIC_DATA_TYPE_UNKNOWN
1785 && specific
->format
== LSMASH_CODEC_SPECIFIC_FORMAT_STRUCTURED
)
1786 continue; /* LSMASH_CODEC_SPECIFIC_DATA_TYPE_UNKNOWN + LSMASH_CODEC_SPECIFIC_FORMAT_STRUCTURED is not supported. */
1787 switch( specific
->type
)
1789 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_AUDIO_COMMON
:
1790 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_CODEC_GLOBAL_HEADER
:
1791 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_AUDIO_FORMAT_SPECIFIC_FLAGS
:
1792 continue; /* These cannot be an extension for 'wave' extension. */
1793 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_AUDIO_CHANNEL_LAYOUT
:
1794 /* (Legacy?) ALAC might have an Audio Channel Layout Box inside 'wave' extension. */
1798 if( lsmash_check_codec_type_identical( audio
->type
, QT_CODEC_TYPE_ALAC_AUDIO
) )
1800 if( (err
= isom_append_channel_layout_extension( specific
, wave
, summary
->channels
)) < 0 )
1806 assert( specific
->format
== LSMASH_CODEC_SPECIFIC_FORMAT_UNSTRUCTURED
1807 || specific
->type
== LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_AUDIO_DECOMPRESSION_PARAMETERS
);
1808 lsmash_codec_specific_t
*cs
= lsmash_convert_codec_specific_format( specific
, LSMASH_CODEC_SPECIFIC_FORMAT_UNSTRUCTURED
);
1810 return LSMASH_ERR_NAMELESS
;
1811 if( cs
->size
< ISOM_BASEBOX_COMMON_SIZE
)
1813 lsmash_destroy_codec_specific_data( cs
);
1816 uint8_t *box_data
= cs
->data
.unstructured
;
1817 uint64_t box_size
= cs
->size
;
1818 lsmash_compact_box_type_t fourcc
= LSMASH_4CC( box_data
[4], box_data
[5], box_data
[6], box_data
[7] );
1819 if( audio
->version
== 2 && fourcc
== QT_BOX_TYPE_ENDA
.fourcc
)
1821 /* Don't append a 'enda' extension if version == 2.
1822 * Endianness is indicated in QuickTime audio format specific flags. */
1823 if( box_size
>= ISOM_BASEBOX_COMMON_SIZE
+ 2 )
1825 /* Override endianness indicated in format specific flags. */
1826 if( box_data
[9] == 1 )
1827 *format_flags
&= ~QT_AUDIO_FORMAT_FLAG_BIG_ENDIAN
;
1829 *format_flags
|= QT_AUDIO_FORMAT_FLAG_BIG_ENDIAN
;
1831 lsmash_destroy_codec_specific_data( cs
);
1834 lsmash_box_type_t box_type
= isom_guess_audio_codec_specific_box_type( audio
->type
, fourcc
);
1835 if( lsmash_check_box_type_identical( box_type
, QT_BOX_TYPE_WAVE
) )
1837 /* It is insane to appened a 'wave' extension to a 'wave' extension. */
1838 lsmash_destroy_codec_specific_data( cs
);
1841 box_type
= lsmash_form_qtff_box_type( box_type
.fourcc
);
1842 /* Determine 'precedence'. */
1843 uint64_t precedence
;
1844 if( lsmash_check_box_type_identical( box_type
, QT_BOX_TYPE_FRMA
) )
1845 precedence
= LSMASH_BOX_PRECEDENCE_QTFF_FRMA
;
1846 else if( lsmash_check_box_type_identical( box_type
, QT_BOX_TYPE_ESDS
) )
1847 precedence
= LSMASH_BOX_PRECEDENCE_QTFF_ESDS
;
1848 else if( lsmash_check_box_type_identical( box_type
, QT_BOX_TYPE_ENDA
) )
1849 precedence
= LSMASH_BOX_PRECEDENCE_QTFF_ENDA
;
1850 else if( lsmash_check_box_type_identical( box_type
, QT_BOX_TYPE_MP4A
) )
1851 precedence
= LSMASH_BOX_PRECEDENCE_QTFF_MP4A
;
1852 else if( lsmash_check_box_type_identical( box_type
, QT_BOX_TYPE_TERMINATOR
) )
1853 precedence
= LSMASH_BOX_PRECEDENCE_QTFF_TERMINATOR
;
1855 precedence
= LSMASH_BOX_PRECEDENCE_HM
;
1856 /* Append the extension. */
1857 err
= isom_add_extension_binary( wave
, box_type
, precedence
, cs
->data
.unstructured
, cs
->size
);
1858 cs
->data
.unstructured
= NULL
; /* Avoid freeing the binary data of the extension. */
1859 lsmash_destroy_codec_specific_data( cs
);
1862 if( isom_is_waveform_audio( box_type
) )
1863 waveform_audio_info_present
= 1;
1868 if( requires_waveform_audio_info
&& !waveform_audio_info_present
1869 && (err
= isom_setup_waveform_audio_info( wave
, audio
, summary
, samples_per_packet
, bytes_per_frame
, sample_size
)) < 0 )
1874 static int isom_set_qtff_template_audio_description( isom_audio_entry_t
*audio
, lsmash_audio_summary_t
*summary
)
1876 audio
->manager
|= LSMASH_QTFF_BASE
;
1877 audio
->type
= lsmash_form_qtff_box_type( audio
->type
.fourcc
);
1878 audio
->version
= (summary
->channels
> 2 || summary
->frequency
> UINT16_MAX
) ? 2 : 1;
1879 /* Try to get QuickTime audio format specific flags. */
1880 lsmash_qt_audio_format_specific_flag format_flags
= QT_AUDIO_FORMAT_FLAG_BIG_ENDIAN
;
1881 for( lsmash_entry_t
*entry
= summary
->opaque
->list
.head
; entry
; entry
= entry
->next
)
1883 lsmash_codec_specific_t
*specific
= (lsmash_codec_specific_t
*)entry
->data
;
1885 || !specific
->data
.structured
)
1887 if( specific
->type
== LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_AUDIO_FORMAT_SPECIFIC_FLAGS
1888 && specific
->format
== LSMASH_CODEC_SPECIFIC_FORMAT_STRUCTURED
)
1890 /* A format specific flags is found.
1891 * Force audio sample description version == 2. */
1892 format_flags
= ((lsmash_qt_audio_format_specific_flags_t
*)specific
->data
.structured
)->format_flags
;
1897 uint32_t samples_per_packet
;
1898 uint32_t bytes_per_frame
;
1899 uint32_t sample_size
;
1900 if( !((summary
->samples_in_frame
== 0 || summary
->bytes_per_frame
== 0 || summary
->sample_size
== 0)
1901 && isom_get_implicit_qt_fixed_comp_audio_sample_quants( audio
, &samples_per_packet
, &bytes_per_frame
, &sample_size
)) )
1903 samples_per_packet
= summary
->samples_in_frame
;
1904 bytes_per_frame
= summary
->bytes_per_frame
;
1905 sample_size
= summary
->sample_size
;
1907 if( !lsmash_check_codec_type_identical( audio
->type
, QT_CODEC_TYPE_MAC3_AUDIO
)
1908 && !lsmash_check_codec_type_identical( audio
->type
, QT_CODEC_TYPE_MAC6_AUDIO
)
1909 && !lsmash_check_codec_type_identical( audio
->type
, QT_CODEC_TYPE_AGSM_AUDIO
)
1910 && !lsmash_check_codec_type_identical( audio
->type
, QT_CODEC_TYPE_ALAW_AUDIO
)
1911 && !lsmash_check_codec_type_identical( audio
->type
, QT_CODEC_TYPE_ULAW_AUDIO
) )
1913 int err
= isom_set_qtff_sound_decompression_parameters( audio
, summary
, &format_flags
,
1914 samples_per_packet
, bytes_per_frame
, sample_size
);
1918 /* Set up common audio description fields. */
1919 audio
->samplesize
= 16;
1920 audio
->packet_size
= 0;
1921 if( audio
->version
== 2 )
1923 audio
->channelcount
= 3;
1924 audio
->compression_ID
= QT_AUDIO_COMPRESSION_ID_VARIABLE_COMPRESSION
;
1925 audio
->samplerate
= 0x00010000;
1926 audio
->sizeOfStructOnly
= 72;
1927 audio
->audioSampleRate
= (union {double d
; uint64_t i
;}){summary
->frequency
}.i
;
1928 audio
->numAudioChannels
= summary
->channels
;
1929 audio
->always7F000000
= 0x7F000000;
1930 audio
->constBitsPerChannel
= 0;
1931 audio
->constBytesPerAudioPacket
= bytes_per_frame
;
1932 audio
->constLPCMFramesPerAudioPacket
= samples_per_packet
;
1933 if( lsmash_check_codec_type_identical( audio
->type
, QT_CODEC_TYPE_ALAC_AUDIO
) )
1935 switch( sample_size
)
1938 audio
->formatSpecificFlags
= QT_ALAC_FORMAT_FLAG_16BIT_SOURCE_DATA
;
1941 audio
->formatSpecificFlags
= QT_ALAC_FORMAT_FLAG_20BIT_SOURCE_DATA
;
1944 audio
->formatSpecificFlags
= QT_ALAC_FORMAT_FLAG_24BIT_SOURCE_DATA
;
1947 audio
->formatSpecificFlags
= QT_ALAC_FORMAT_FLAG_32BIT_SOURCE_DATA
;
1955 if( format_flags
& QT_AUDIO_FORMAT_FLAG_FLOAT
)
1956 format_flags
&= ~QT_AUDIO_FORMAT_FLAG_SIGNED_INTEGER
;
1957 if( format_flags
& QT_AUDIO_FORMAT_FLAG_PACKED
)
1958 format_flags
&= ~QT_AUDIO_FORMAT_FLAG_ALIGNED_HIGH
;
1959 audio
->formatSpecificFlags
= format_flags
;
1962 else /* if( audio->version == 1 ) */
1964 audio
->channelcount
= LSMASH_MIN( summary
->channels
, 2 );
1965 audio
->compression_ID
= QT_AUDIO_COMPRESSION_ID_FIXED_COMPRESSION
;
1966 audio
->samplerate
= summary
->frequency
<< 16;
1967 audio
->samplesPerPacket
= samples_per_packet
;
1968 audio
->bytesPerPacket
= bytes_per_frame
/ summary
->channels
;
1969 audio
->bytesPerFrame
= bytes_per_frame
; /* sample_size field in stsz box is NOT used. */
1970 audio
->bytesPerSample
= 1 + (sample_size
!= 8);
1975 static void isom_set_samplerate_division_of_media_timescale( isom_audio_entry_t
*audio
, int strict
)
1977 if( audio
->parent
/* stsd */
1978 && audio
->parent
->parent
/* stbl */
1979 && audio
->parent
->parent
->parent
/* minf */
1980 && audio
->parent
->parent
->parent
->parent
/* mdia */
1981 && lsmash_check_box_type_identical( audio
->parent
->parent
->parent
->parent
->type
, ISOM_BOX_TYPE_MDIA
)
1982 && ((isom_mdia_t
*)audio
->parent
->parent
->parent
->parent
)->mdhd
)
1984 /* Make an effort to match the timescale with samplerate, or be an integer multiple of it. */
1985 uint32_t orig_timescale
= ((isom_mdia_t
*)audio
->parent
->parent
->parent
->parent
)->mdhd
->timescale
;
1986 uint32_t timescale
= orig_timescale
;
1988 while( timescale
> UINT16_MAX
&& timescale
> 1 )
1990 if( timescale
% i
== 0 )
1995 if( timescale
!= orig_timescale
&& strict
)
1996 lsmash_log( NULL
, LSMASH_LOG_WARNING
, "samplerate does not match the media timescale.\n" );
1997 if( timescale
<= UINT16_MAX
&& timescale
> 1 )
1999 audio
->samplerate
= timescale
<< 16;
2003 audio
->samplerate
= 0;
2006 static int isom_set_isom_template_audio_description( isom_audio_entry_t
*audio
, lsmash_audio_summary_t
*summary
)
2008 audio
->version
= 0; /* reserved */
2009 audio
->revision_level
= 0; /* reserved */
2010 audio
->vendor
= 0; /* reserved */
2011 audio
->channelcount
= 2; /* template */
2012 audio
->samplesize
= 16; /* template */
2013 audio
->compression_ID
= 0; /* pre_defined */
2014 audio
->packet_size
= 0; /* reserved */
2015 /* template : default output audio sampling rate at playback */
2016 if( summary
->frequency
<= UINT16_MAX
)
2017 audio
->samplerate
= summary
->frequency
<< 16;
2019 isom_set_samplerate_division_of_media_timescale( audio
, 0 );
2023 static int isom_set_isom_amr_audio_description( isom_audio_entry_t
*audio
, int wb
)
2025 /* For AMR-NB and AMR-WB stream, these fields are not meaningful. */
2026 audio
->version
= 0; /* always 0 */
2027 audio
->revision_level
= 0; /* always 0 */
2028 audio
->vendor
= 0; /* always 0 */
2029 audio
->channelcount
= 2; /* always 2 although the actual number of channels is always 1 */
2030 audio
->samplesize
= 16; /* always 16 */
2031 audio
->compression_ID
= 0; /* always 0 */
2032 audio
->packet_size
= 0; /* always 0 */
2033 /* Set samplerate by trying to copy from Media Header Box of this media though the
2034 * actual samplerate is 8000 Hz for AMR-NB and 16000 Hz for AMR-WB.
2035 * 3GPP and 3GPP2 has no restriction for media timescale. Therefore, users should
2036 * set suitable media timescale by themselves within the bounds of common sense. */
2037 isom_set_samplerate_division_of_media_timescale( audio
, 1 );
2038 if( audio
->samplerate
== 0 )
2039 /* Set hard-coded but correct samplerate in the CODEC level. */
2040 audio
->samplerate
= wb
? 8000 : 16000;
2044 int isom_setup_audio_description( isom_stsd_t
*stsd
, lsmash_codec_type_t sample_type
, lsmash_audio_summary_t
*summary
)
2046 if( !stsd
|| !stsd
->file
|| !summary
)
2047 return LSMASH_ERR_NAMELESS
;
2048 int err
= isom_check_valid_summary( (lsmash_summary_t
*)summary
);
2051 isom_audio_entry_t
*audio
= isom_add_audio_description( stsd
, sample_type
);
2053 return LSMASH_ERR_NAMELESS
;
2054 audio
->data_reference_index
= summary
->data_ref_index
;
2055 lsmash_file_t
*file
= stsd
->file
;
2056 lsmash_codec_type_t audio_type
= audio
->type
;
2057 if( lsmash_check_codec_type_identical( audio_type
, ISOM_CODEC_TYPE_MP4A_AUDIO
)
2058 || lsmash_check_codec_type_identical( audio_type
, QT_CODEC_TYPE_MP4A_AUDIO
) )
2060 if( (file
->ftyp
&& file
->ftyp
->major_brand
== ISOM_BRAND_TYPE_QT
)
2061 || (!file
->ftyp
&& (file
->qt_compatible
|| (file
->moov
&& !file
->moov
->iods
))) )
2062 err
= isom_set_qtff_mp4a_description( audio
, summary
);
2064 err
= isom_set_isom_mp4a_description( audio
, summary
);
2066 else if( isom_is_lpcm_audio( audio
) )
2067 err
= isom_set_qtff_lpcm_description( audio
, summary
);
2068 else if( lsmash_check_codec_type_identical( audio_type
, ISOM_CODEC_TYPE_DTSC_AUDIO
)
2069 || lsmash_check_codec_type_identical( audio_type
, ISOM_CODEC_TYPE_DTSE_AUDIO
)
2070 || lsmash_check_codec_type_identical( audio_type
, ISOM_CODEC_TYPE_DTSH_AUDIO
)
2071 || lsmash_check_codec_type_identical( audio_type
, ISOM_CODEC_TYPE_DTSL_AUDIO
) )
2072 err
= isom_set_isom_dts_description( audio
, summary
);
2073 else if( file
->qt_compatible
)
2074 err
= isom_set_qtff_template_audio_description( audio
, summary
);
2075 else if( lsmash_check_codec_type_identical( audio_type
, ISOM_CODEC_TYPE_SAMR_AUDIO
) )
2076 err
= isom_set_isom_amr_audio_description( audio
, 0 );
2077 else if( lsmash_check_codec_type_identical( audio_type
, ISOM_CODEC_TYPE_SAWB_AUDIO
) )
2078 err
= isom_set_isom_amr_audio_description( audio
, 1 );
2080 err
= isom_set_isom_template_audio_description( audio
, summary
);
2083 err
= LSMASH_ERR_NAMELESS
;
2084 /* Don't use audio_type since audio->type might have changed. */
2085 for( lsmash_entry_t
*entry
= summary
->opaque
->list
.head
; entry
; entry
= entry
->next
)
2087 lsmash_codec_specific_t
*specific
= (lsmash_codec_specific_t
*)entry
->data
;
2090 if( specific
->type
== LSMASH_CODEC_SPECIFIC_DATA_TYPE_UNKNOWN
2091 && specific
->format
== LSMASH_CODEC_SPECIFIC_FORMAT_STRUCTURED
)
2092 continue; /* LSMASH_CODEC_SPECIFIC_DATA_TYPE_UNKNOWN + LSMASH_CODEC_SPECIFIC_FORMAT_STRUCTURED is not supported. */
2093 switch( specific
->type
)
2095 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_AUDIO_COMMON
:
2097 if( specific
->format
== LSMASH_CODEC_SPECIFIC_FORMAT_UNSTRUCTURED
)
2098 continue; /* Ignore since not fatal. */
2099 lsmash_qt_audio_common_t
*data
= (lsmash_qt_audio_common_t
*)specific
->data
.structured
;
2100 audio
->revision_level
= data
->revision_level
;
2101 audio
->vendor
= data
->vendor
;
2102 if( audio
->version
== 1
2103 && !isom_is_lpcm_audio( audio
)
2104 && data
->compression_ID
!= QT_AUDIO_COMPRESSION_ID_NOT_COMPRESSED
)
2106 /* Compressed audio must not be set to QT_AUDIO_COMPRESSION_ID_NOT_COMPRESSED. */
2107 audio
->compression_ID
= data
->compression_ID
;
2108 if( audio
->compression_ID
== QT_AUDIO_COMPRESSION_ID_VARIABLE_COMPRESSION
)
2110 /* For variable compression, bytesPerPacket and bytesPerFrame are reserved and should be set to 0. */
2111 audio
->bytesPerPacket
= 0;
2112 audio
->bytesPerFrame
= 0;
2117 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_AUDIO_CHANNEL_LAYOUT
:
2119 if( !file
->qt_compatible
2120 && !lsmash_check_codec_type_identical( audio
->type
, ISOM_CODEC_TYPE_ALAC_AUDIO
)
2121 && !lsmash_check_codec_type_identical( audio
->type
, QT_CODEC_TYPE_ALAC_AUDIO
) )
2123 if( (err
= isom_append_channel_layout_extension( specific
, audio
, summary
->channels
)) < 0 )
2127 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_CODEC_GLOBAL_HEADER
:
2129 lsmash_codec_specific_t
*cs
= lsmash_convert_codec_specific_format( specific
, LSMASH_CODEC_SPECIFIC_FORMAT_STRUCTURED
);
2132 lsmash_codec_global_header_t
*data
= (lsmash_codec_global_header_t
*)cs
->data
.structured
;
2133 isom_glbl_t
*glbl
= isom_add_glbl( audio
);
2136 lsmash_destroy_codec_specific_data( cs
);
2139 glbl
->header_size
= data
->header_size
;
2140 glbl
->header_data
= lsmash_memdup( data
->header_data
, data
->header_size
);
2141 lsmash_destroy_codec_specific_data( cs
);
2142 if( !glbl
->header_data
)
2144 isom_remove_box_by_itself( glbl
);
2145 err
= LSMASH_ERR_MEMORY_ALLOC
;
2150 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_AUDIO_FORMAT_SPECIFIC_FLAGS
:
2151 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_AUDIO_DECOMPRESSION_PARAMETERS
:
2152 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_MP4SYS_DECODER_CONFIG
:
2153 break; /* shall be set up already */
2154 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_AUDIO_ALAC
:
2155 if( file
->qt_compatible
)
2156 continue; /* shall be set up already */
2159 lsmash_codec_specific_t
*cs
= lsmash_convert_codec_specific_format( specific
, LSMASH_CODEC_SPECIFIC_FORMAT_UNSTRUCTURED
);
2162 if( cs
->size
< ISOM_BASEBOX_COMMON_SIZE
)
2164 lsmash_destroy_codec_specific_data( cs
);
2167 uint8_t *box_data
= cs
->data
.unstructured
;
2168 lsmash_compact_box_type_t fourcc
= LSMASH_4CC( box_data
[4], box_data
[5], box_data
[6], box_data
[7] );
2169 lsmash_box_type_t box_type
= isom_guess_audio_codec_specific_box_type( audio
->type
, fourcc
);
2170 if( lsmash_check_box_type_identical( box_type
, QT_BOX_TYPE_WAVE
) )
2172 /* CODEC specific info shall be already inside 'wave' extension. */
2173 lsmash_destroy_codec_specific_data( cs
);
2176 /* Append the extension. */
2177 err
= isom_add_extension_binary( audio
, box_type
, LSMASH_BOX_PRECEDENCE_HM
, cs
->data
.unstructured
, cs
->size
);
2178 cs
->data
.unstructured
= NULL
; /* Avoid freeing the binary data of the extension. */
2179 lsmash_destroy_codec_specific_data( cs
);
2186 if( audio
->version
== 0 )
2187 audio
->compression_ID
= QT_AUDIO_COMPRESSION_ID_NOT_COMPRESSED
;
2188 else if( audio
->version
== 2 )
2189 audio
->compression_ID
= QT_AUDIO_COMPRESSION_ID_VARIABLE_COMPRESSION
;
2192 isom_remove_box_by_itself( audio
);
2196 int isom_setup_tx3g_description( isom_stsd_t
*stsd
, lsmash_summary_t
*summary
)
2198 isom_tx3g_entry_t
*tx3g
= isom_add_tx3g_description( stsd
);
2200 return LSMASH_ERR_NAMELESS
;
2201 /* We create a dummy font record to make valid font_ID in the sample description.
2202 * The specification (3GPP TS 26.245) does not forbid the value 0 for the identifier,
2203 * but we set 1 to it as track_ID begins from 1. */
2204 tx3g
->data_reference_index
= summary
->data_ref_index
;
2205 tx3g
->font_ID
= 1; /* ID of the default font record */
2206 int err
= LSMASH_ERR_MEMORY_ALLOC
;
2207 isom_ftab_t
*ftab
= isom_add_ftab( tx3g
);
2210 err
= LSMASH_ERR_NAMELESS
;
2213 isom_font_record_t
*font
= lsmash_malloc( sizeof(isom_font_record_t
) );
2216 if( lsmash_add_entry( ftab
->list
, font
) < 0 )
2218 lsmash_free( font
);
2221 const char font_names
[] = "Serif,Sans-serif,Monospace";
2223 font
->font_name_length
= sizeof(font_names
);
2224 font
->font_name
= lsmash_memdup( font_names
, sizeof(font_names
) );
2225 if( !font
->font_name
)
2229 isom_remove_box_by_itself( tx3g
);
2233 static lsmash_codec_specific_data_type
isom_get_codec_specific_data_type( lsmash_compact_box_type_t extension_fourcc
)
2235 static struct codec_specific_data_type_table_tag
2237 lsmash_compact_box_type_t extension_fourcc
;
2238 lsmash_codec_specific_data_type data_type
;
2239 } codec_specific_data_type_table
[32] = { { 0, LSMASH_CODEC_SPECIFIC_DATA_TYPE_UNKNOWN
} };
2240 if( codec_specific_data_type_table
[0].data_type
== LSMASH_CODEC_SPECIFIC_DATA_TYPE_UNKNOWN
)
2243 #define ADD_CODEC_SPECIFIC_DATA_TYPE_TABLE_ELEMENT( extension_type, data_type ) \
2244 codec_specific_data_type_table[i++] = (struct codec_specific_data_type_table_tag){ extension_type.fourcc, data_type }
2245 ADD_CODEC_SPECIFIC_DATA_TYPE_TABLE_ELEMENT( ISOM_BOX_TYPE_AVCC
, LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_VIDEO_H264
);
2246 ADD_CODEC_SPECIFIC_DATA_TYPE_TABLE_ELEMENT( ISOM_BOX_TYPE_HVCC
, LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_VIDEO_HEVC
);
2247 ADD_CODEC_SPECIFIC_DATA_TYPE_TABLE_ELEMENT( ISOM_BOX_TYPE_DVC1
, LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_VIDEO_VC_1
);
2248 ADD_CODEC_SPECIFIC_DATA_TYPE_TABLE_ELEMENT( ISOM_BOX_TYPE_DAC3
, LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_AUDIO_AC_3
);
2249 ADD_CODEC_SPECIFIC_DATA_TYPE_TABLE_ELEMENT( ISOM_BOX_TYPE_DEC3
, LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_AUDIO_EC_3
);
2250 ADD_CODEC_SPECIFIC_DATA_TYPE_TABLE_ELEMENT( ISOM_BOX_TYPE_DDTS
, LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_AUDIO_DTS
);
2251 ADD_CODEC_SPECIFIC_DATA_TYPE_TABLE_ELEMENT( ISOM_BOX_TYPE_ALAC
, LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_AUDIO_ALAC
);
2252 ADD_CODEC_SPECIFIC_DATA_TYPE_TABLE_ELEMENT( ISOM_BOX_TYPE_ESDS
, LSMASH_CODEC_SPECIFIC_DATA_TYPE_MP4SYS_DECODER_CONFIG
);
2253 ADD_CODEC_SPECIFIC_DATA_TYPE_TABLE_ELEMENT( ISOM_BOX_TYPE_STSL
, LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_VIDEO_SAMPLE_SCALE
);
2254 ADD_CODEC_SPECIFIC_DATA_TYPE_TABLE_ELEMENT( ISOM_BOX_TYPE_BTRT
, LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_VIDEO_H264_BITRATE
);
2255 //ADD_CODEC_SPECIFIC_DATA_TYPE_TABLE_ELEMENT( QT_BOX_TYPE_ALAC, LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_AUDIO_ALAC );
2256 //ADD_CODEC_SPECIFIC_DATA_TYPE_TABLE_ELEMENT( QT_BOX_TYPE_ESDS, LSMASH_CODEC_SPECIFIC_DATA_TYPE_MP4SYS_DECODER_CONFIG );
2257 ADD_CODEC_SPECIFIC_DATA_TYPE_TABLE_ELEMENT( QT_BOX_TYPE_FIEL
, LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_VIDEO_FIELD_INFO
);
2258 ADD_CODEC_SPECIFIC_DATA_TYPE_TABLE_ELEMENT( QT_BOX_TYPE_CSPC
, LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_VIDEO_PIXEL_FORMAT
);
2259 ADD_CODEC_SPECIFIC_DATA_TYPE_TABLE_ELEMENT( QT_BOX_TYPE_SGBT
, LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_VIDEO_SIGNIFICANT_BITS
);
2260 ADD_CODEC_SPECIFIC_DATA_TYPE_TABLE_ELEMENT( QT_BOX_TYPE_GAMA
, LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_VIDEO_GAMMA_LEVEL
);
2261 ADD_CODEC_SPECIFIC_DATA_TYPE_TABLE_ELEMENT( QT_BOX_TYPE_CHAN
, LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_AUDIO_CHANNEL_LAYOUT
);
2262 ADD_CODEC_SPECIFIC_DATA_TYPE_TABLE_ELEMENT( QT_BOX_TYPE_GLBL
, LSMASH_CODEC_SPECIFIC_DATA_TYPE_CODEC_GLOBAL_HEADER
);
2263 ADD_CODEC_SPECIFIC_DATA_TYPE_TABLE_ELEMENT( LSMASH_BOX_TYPE_UNSPECIFIED
, LSMASH_CODEC_SPECIFIC_DATA_TYPE_UNKNOWN
);
2264 #undef ADD_CODEC_SPECIFIC_DATA_TYPE_TABLE_ELEMENT
2266 lsmash_codec_specific_data_type data_type
= LSMASH_CODEC_SPECIFIC_DATA_TYPE_UNKNOWN
;
2267 for( int i
= 0; codec_specific_data_type_table
[i
].data_type
!= LSMASH_CODEC_SPECIFIC_DATA_TYPE_UNKNOWN
; i
++ )
2268 if( extension_fourcc
== codec_specific_data_type_table
[i
].extension_fourcc
)
2270 data_type
= codec_specific_data_type_table
[i
].data_type
;
2276 lsmash_summary_t
*isom_create_video_summary_from_description( isom_sample_entry_t
*sample_entry
)
2280 isom_visual_entry_t
*visual
= (isom_visual_entry_t
*)sample_entry
;
2281 lsmash_video_summary_t
*summary
= (lsmash_video_summary_t
*)lsmash_create_summary( LSMASH_SUMMARY_TYPE_VIDEO
);
2284 summary
->sample_type
= visual
->type
;
2285 summary
->data_ref_index
= visual
->data_reference_index
;
2286 summary
->width
= visual
->width
;
2287 summary
->height
= visual
->height
;
2288 summary
->depth
= visual
->depth
;
2289 memcpy( summary
->compressorname
, visual
->compressorname
, 32 );
2290 summary
->compressorname
[32] = '\0';
2291 if( isom_is_qt_video( summary
->sample_type
) )
2293 lsmash_codec_specific_t
*specific
= lsmash_create_codec_specific_data( LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_VIDEO_COMMON
,
2294 LSMASH_CODEC_SPECIFIC_FORMAT_STRUCTURED
);
2297 lsmash_qt_video_common_t
*data
= (lsmash_qt_video_common_t
*)specific
->data
.structured
;
2298 data
->revision_level
= visual
->revision_level
;
2299 data
->vendor
= visual
->vendor
;
2300 data
->temporalQuality
= visual
->temporalQuality
;
2301 data
->spatialQuality
= visual
->spatialQuality
;
2302 data
->horizontal_resolution
= visual
->horizresolution
;
2303 data
->vertical_resolution
= visual
->vertresolution
;
2304 data
->dataSize
= visual
->dataSize
;
2305 data
->frame_count
= visual
->frame_count
;
2306 data
->color_table_ID
= visual
->color_table_ID
;
2307 if( visual
->color_table_ID
== 0 )
2309 isom_qt_color_table_t
*src_ct
= &visual
->color_table
;
2310 if( !src_ct
->array
)
2312 lsmash_destroy_codec_specific_data( specific
);
2315 uint16_t element_count
= LSMASH_MIN( src_ct
->size
+ 1, 256 );
2316 lsmash_qt_color_table_t
*dst_ct
= &data
->color_table
;
2317 dst_ct
->seed
= src_ct
->seed
;
2318 dst_ct
->flags
= src_ct
->flags
;
2319 dst_ct
->size
= src_ct
->size
;
2320 for( uint16_t i
= 0; i
< element_count
; i
++ )
2322 dst_ct
->array
[i
].unused
= src_ct
->array
[i
].value
;
2323 dst_ct
->array
[i
].r
= src_ct
->array
[i
].r
;
2324 dst_ct
->array
[i
].g
= src_ct
->array
[i
].g
;
2325 dst_ct
->array
[i
].b
= src_ct
->array
[i
].b
;
2328 if( lsmash_add_entry( &summary
->opaque
->list
, specific
) < 0 )
2330 lsmash_destroy_codec_specific_data( specific
);
2334 for( lsmash_entry_t
*entry
= visual
->extensions
.head
; entry
; entry
= entry
->next
)
2336 isom_box_t
*box
= (isom_box_t
*)entry
->data
;
2339 if( !(box
->manager
& LSMASH_BINARY_CODED_BOX
) )
2341 lsmash_codec_specific_t
*specific
= NULL
;
2342 if( lsmash_check_box_type_identical( box
->type
, ISOM_BOX_TYPE_CLAP
) )
2344 isom_clap_t
*clap
= (isom_clap_t
*)box
;
2345 summary
->clap
.width
.n
= clap
->cleanApertureWidthN
;
2346 summary
->clap
.width
.d
= clap
->cleanApertureWidthD
;
2347 summary
->clap
.height
.n
= clap
->cleanApertureHeightN
;
2348 summary
->clap
.height
.d
= clap
->cleanApertureHeightD
;
2349 summary
->clap
.horizontal_offset
.n
= clap
->horizOffN
;
2350 summary
->clap
.horizontal_offset
.d
= clap
->horizOffD
;
2351 summary
->clap
.vertical_offset
.n
= clap
->vertOffN
;
2352 summary
->clap
.vertical_offset
.d
= clap
->vertOffD
;
2355 else if( lsmash_check_box_type_identical( box
->type
, ISOM_BOX_TYPE_PASP
) )
2357 isom_pasp_t
*pasp
= (isom_pasp_t
*)box
;
2358 summary
->par_h
= pasp
->hSpacing
;
2359 summary
->par_v
= pasp
->vSpacing
;
2362 else if( lsmash_check_box_type_identical( box
->type
, ISOM_BOX_TYPE_COLR
)
2363 || lsmash_check_box_type_identical( box
->type
, QT_BOX_TYPE_COLR
) )
2365 isom_colr_t
*colr
= (isom_colr_t
*)box
;
2366 summary
->color
.primaries_index
= colr
->primaries_index
;
2367 summary
->color
.transfer_index
= colr
->transfer_function_index
;
2368 summary
->color
.matrix_index
= colr
->matrix_index
;
2369 summary
->color
.full_range
= colr
->full_range_flag
;
2372 else if( lsmash_check_box_type_identical( box
->type
, ISOM_BOX_TYPE_STSL
) )
2374 specific
= lsmash_create_codec_specific_data( LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_VIDEO_SAMPLE_SCALE
,
2375 LSMASH_CODEC_SPECIFIC_FORMAT_STRUCTURED
);
2378 isom_stsl_t
*stsl
= (isom_stsl_t
*)box
;
2379 lsmash_isom_sample_scale_t
*data
= (lsmash_isom_sample_scale_t
*)specific
->data
.structured
;
2380 data
->constraint_flag
= stsl
->constraint_flag
;
2381 data
->scale_method
= stsl
->scale_method
;
2382 data
->display_center_x
= stsl
->display_center_x
;
2383 data
->display_center_y
= stsl
->display_center_y
;
2385 else if( lsmash_check_box_type_identical( box
->type
, ISOM_BOX_TYPE_BTRT
) )
2387 specific
= lsmash_create_codec_specific_data( LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_VIDEO_H264_BITRATE
,
2388 LSMASH_CODEC_SPECIFIC_FORMAT_STRUCTURED
);
2391 isom_btrt_t
*btrt
= (isom_btrt_t
*)box
;
2392 lsmash_h264_bitrate_t
*data
= (lsmash_h264_bitrate_t
*)specific
->data
.structured
;
2393 data
->bufferSizeDB
= btrt
->bufferSizeDB
;
2394 data
->maxBitrate
= btrt
->maxBitrate
;
2395 data
->avgBitrate
= btrt
->avgBitrate
;
2397 else if( lsmash_check_box_type_identical( box
->type
, QT_BOX_TYPE_FIEL
) )
2399 specific
= lsmash_create_codec_specific_data( LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_VIDEO_FIELD_INFO
,
2400 LSMASH_CODEC_SPECIFIC_FORMAT_STRUCTURED
);
2403 isom_fiel_t
*fiel
= (isom_fiel_t
*)box
;
2404 lsmash_qt_field_info_t
*data
= (lsmash_qt_field_info_t
*)specific
->data
.structured
;
2405 data
->fields
= fiel
->fields
;
2406 data
->detail
= fiel
->detail
;
2408 else if( lsmash_check_box_type_identical( box
->type
, QT_BOX_TYPE_CSPC
) )
2410 specific
= lsmash_create_codec_specific_data( LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_VIDEO_PIXEL_FORMAT
,
2411 LSMASH_CODEC_SPECIFIC_FORMAT_STRUCTURED
);
2414 isom_cspc_t
*cspc
= (isom_cspc_t
*)box
;
2415 lsmash_qt_pixel_format_t
*data
= (lsmash_qt_pixel_format_t
*)specific
->data
.structured
;
2416 data
->pixel_format
= cspc
->pixel_format
;
2418 else if( lsmash_check_box_type_identical( box
->type
, QT_BOX_TYPE_SGBT
) )
2420 specific
= lsmash_create_codec_specific_data( LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_VIDEO_SIGNIFICANT_BITS
,
2421 LSMASH_CODEC_SPECIFIC_FORMAT_STRUCTURED
);
2424 isom_sgbt_t
*sgbt
= (isom_sgbt_t
*)box
;
2425 lsmash_qt_significant_bits_t
*data
= (lsmash_qt_significant_bits_t
*)specific
->data
.structured
;
2426 data
->significantBits
= sgbt
->significantBits
;
2428 else if( lsmash_check_box_type_identical( box
->type
, QT_BOX_TYPE_GLBL
) )
2430 specific
= lsmash_create_codec_specific_data( LSMASH_CODEC_SPECIFIC_DATA_TYPE_CODEC_GLOBAL_HEADER
,
2431 LSMASH_CODEC_SPECIFIC_FORMAT_STRUCTURED
);
2434 isom_glbl_t
*glbl
= (isom_glbl_t
*)box
;
2435 lsmash_codec_global_header_t
*data
= (lsmash_codec_global_header_t
*)specific
->data
.structured
;
2436 data
->header_size
= glbl
->header_size
;
2437 data
->header_data
= lsmash_memdup( glbl
->header_data
, glbl
->header_size
);
2438 if( !data
->header_data
)
2440 lsmash_destroy_codec_specific_data( specific
);
2446 if( lsmash_add_entry( &summary
->opaque
->list
, specific
) < 0 )
2448 lsmash_destroy_codec_specific_data( specific
);
2454 if( box
->size
< ISOM_BASEBOX_COMMON_SIZE
)
2456 uint8_t *data
= box
->binary
;
2457 lsmash_compact_box_type_t fourcc
= LSMASH_4CC( data
[4], data
[5], data
[6], data
[7] );
2458 lsmash_codec_specific_data_type type
= isom_get_codec_specific_data_type( fourcc
);
2459 lsmash_codec_specific_t
*specific
= lsmash_create_codec_specific_data( type
, LSMASH_CODEC_SPECIFIC_FORMAT_UNSTRUCTURED
);
2462 specific
->size
= box
->size
;
2463 specific
->data
.unstructured
= lsmash_memdup( box
->binary
, box
->size
);
2464 if( !specific
->data
.unstructured
2465 || lsmash_add_entry( &summary
->opaque
->list
, specific
) < 0 )
2467 lsmash_destroy_codec_specific_data( specific
);
2472 return (lsmash_summary_t
*)summary
;
2474 lsmash_cleanup_summary( (lsmash_summary_t
*)summary
);
2478 static int isom_append_structured_mp4sys_decoder_config( lsmash_codec_specific_list_t
*opaque
, isom_esds_t
*esds
)
2480 lsmash_bs_t
*bs
= lsmash_bs_create();
2482 return LSMASH_ERR_MEMORY_ALLOC
;
2483 /* Put box size, type, version and flags fields. */
2484 lsmash_bs_put_be32( bs
, 0 );
2485 lsmash_bs_put_be32( bs
, ISOM_BOX_TYPE_ESDS
.fourcc
);
2486 lsmash_bs_put_be32( bs
, 0 );
2487 /* Put ES Descriptor. */
2488 mp4sys_update_descriptor_size( esds
->ES
);
2489 mp4sys_write_descriptor( bs
, esds
->ES
);
2490 /* Export ES Descriptor Box as binary string. */
2492 uint8_t *esds_data
= lsmash_bs_export_data( bs
, &esds_size
);
2493 lsmash_bs_cleanup( bs
);
2495 return LSMASH_ERR_NAMELESS
;
2496 /* Update box size. */
2497 LSMASH_SET_BE32( esds_data
, esds_size
);
2498 lsmash_codec_specific_data_type type
= isom_get_codec_specific_data_type( ISOM_BOX_TYPE_ESDS
.fourcc
);
2499 lsmash_codec_specific_t
*specific
= lsmash_create_codec_specific_data( type
, LSMASH_CODEC_SPECIFIC_FORMAT_UNSTRUCTURED
);
2502 lsmash_free( esds_data
);
2503 return LSMASH_ERR_NAMELESS
;
2505 specific
->data
.unstructured
= esds_data
;
2506 specific
->size
= esds_size
;
2507 /* Convert unstructured CODEC specific data format into structured, and append it to the opaque list. */
2508 lsmash_codec_specific_t
*conv
= lsmash_convert_codec_specific_format( specific
, LSMASH_CODEC_SPECIFIC_FORMAT_STRUCTURED
);
2509 lsmash_destroy_codec_specific_data( specific
);
2511 return LSMASH_ERR_NAMELESS
;
2512 if( lsmash_add_entry( &opaque
->list
, conv
) < 0 )
2514 lsmash_destroy_codec_specific_data( conv
);
2515 return LSMASH_ERR_MEMORY_ALLOC
;
2520 lsmash_summary_t
*isom_create_audio_summary_from_description( isom_sample_entry_t
*sample_entry
)
2522 if( !sample_entry
|| !sample_entry
->file
|| !sample_entry
->parent
)
2524 isom_audio_entry_t
*audio
= (isom_audio_entry_t
*)sample_entry
;
2525 lsmash_audio_summary_t
*summary
= (lsmash_audio_summary_t
*)lsmash_create_summary( LSMASH_SUMMARY_TYPE_AUDIO
);
2528 summary
->sample_type
= audio
->type
;
2529 summary
->data_ref_index
= audio
->data_reference_index
;
2530 summary
->sample_size
= audio
->samplesize
;
2531 summary
->channels
= audio
->channelcount
;
2532 summary
->frequency
= audio
->samplerate
>> 16;
2533 if( ((isom_stsd_t
*)audio
->parent
)->version
== 0
2534 && audio
->file
->qt_compatible
2535 && isom_is_qt_audio( audio
->type
) )
2537 if( audio
->version
== 0 )
2538 isom_get_implicit_qt_fixed_comp_audio_sample_quants( audio
, &summary
->samples_in_frame
, &summary
->bytes_per_frame
, &summary
->sample_size
);
2539 else if( audio
->version
== 1 )
2541 summary
->channels
= audio
->bytesPerPacket
? audio
->bytesPerFrame
/ audio
->bytesPerPacket
: audio
->channelcount
;
2542 summary
->sample_size
= audio
->bytesPerPacket
* 8;
2543 summary
->samples_in_frame
= audio
->samplesPerPacket
;
2544 summary
->bytes_per_frame
= audio
->bytesPerFrame
;
2546 else if( audio
->version
== 2 )
2548 summary
->frequency
= (union {uint64_t i
; double d
;}){audio
->audioSampleRate
}.d
;
2549 summary
->channels
= audio
->numAudioChannels
;
2550 summary
->sample_size
= audio
->constBitsPerChannel
;
2551 summary
->samples_in_frame
= audio
->constLPCMFramesPerAudioPacket
;
2552 summary
->bytes_per_frame
= audio
->constBytesPerAudioPacket
;
2554 lsmash_codec_specific_t
*specific
= lsmash_create_codec_specific_data( LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_AUDIO_COMMON
,
2555 LSMASH_CODEC_SPECIFIC_FORMAT_STRUCTURED
);
2558 lsmash_qt_audio_common_t
*common
= (lsmash_qt_audio_common_t
*)specific
->data
.structured
;
2559 common
->revision_level
= audio
->revision_level
;
2560 common
->vendor
= audio
->vendor
;
2561 common
->compression_ID
= audio
->compression_ID
;
2562 if( lsmash_add_entry( &summary
->opaque
->list
, specific
) < 0 )
2564 lsmash_destroy_codec_specific_data( specific
);
2567 if( isom_is_lpcm_audio( audio
) )
2569 specific
= lsmash_create_codec_specific_data( LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_AUDIO_FORMAT_SPECIFIC_FLAGS
,
2570 LSMASH_CODEC_SPECIFIC_FORMAT_STRUCTURED
);
2573 lsmash_qt_audio_format_specific_flags_t
*data
= (lsmash_qt_audio_format_specific_flags_t
*)specific
->data
.structured
;
2574 if( audio
->version
== 2 )
2575 data
->format_flags
= audio
->formatSpecificFlags
;
2578 data
->format_flags
= 0;
2579 /* Here, don't override samplesize.
2580 * We should trust samplesize field in the description for misused CODEC indentifier. */
2581 lsmash_codec_type_t audio_type
= audio
->type
;
2582 if( lsmash_check_codec_type_identical( audio_type
, QT_CODEC_TYPE_FL32_AUDIO
)
2583 || lsmash_check_codec_type_identical( audio_type
, QT_CODEC_TYPE_FL64_AUDIO
) )
2584 data
->format_flags
= QT_LPCM_FORMAT_FLAG_FLOAT
;
2585 else if( lsmash_check_codec_type_identical( audio_type
, QT_CODEC_TYPE_TWOS_AUDIO
)
2586 || lsmash_check_codec_type_identical( audio_type
, QT_CODEC_TYPE_NONE_AUDIO
)
2587 || lsmash_check_codec_type_identical( audio_type
, QT_CODEC_TYPE_NOT_SPECIFIED
) )
2589 if( lsmash_check_codec_type_identical( audio_type
, QT_CODEC_TYPE_TWOS_AUDIO
) )
2590 data
->format_flags
= QT_LPCM_FORMAT_FLAG_BIG_ENDIAN
| QT_AUDIO_FORMAT_FLAG_SIGNED_INTEGER
;
2591 if( summary
->sample_size
> 8 )
2592 data
->format_flags
= QT_LPCM_FORMAT_FLAG_BIG_ENDIAN
;
2595 isom_wave_t
*wave
= (isom_wave_t
*)isom_get_extension_box_format( &audio
->extensions
, QT_BOX_TYPE_WAVE
);
2596 if( wave
&& wave
->enda
&& !wave
->enda
->littleEndian
)
2597 data
->format_flags
|= QT_LPCM_FORMAT_FLAG_BIG_ENDIAN
;
2598 if( lsmash_add_entry( &summary
->opaque
->list
, specific
) < 0 )
2600 lsmash_destroy_codec_specific_data( specific
);
2604 else if( audio
->version
== 2
2605 && (lsmash_check_codec_type_identical( audio
->type
, ISOM_CODEC_TYPE_ALAC_AUDIO
)
2606 || lsmash_check_codec_type_identical( audio
->type
, QT_CODEC_TYPE_ALAC_AUDIO
)) )
2607 switch( audio
->formatSpecificFlags
)
2609 case QT_ALAC_FORMAT_FLAG_16BIT_SOURCE_DATA
:
2610 summary
->sample_size
= 16;
2612 case QT_ALAC_FORMAT_FLAG_20BIT_SOURCE_DATA
:
2613 summary
->sample_size
= 20;
2615 case QT_ALAC_FORMAT_FLAG_24BIT_SOURCE_DATA
:
2616 summary
->sample_size
= 24;
2618 case QT_ALAC_FORMAT_FLAG_32BIT_SOURCE_DATA
:
2619 summary
->sample_size
= 32;
2625 else if( lsmash_check_codec_type_identical( audio
->type
, ISOM_CODEC_TYPE_SAMR_AUDIO
) )
2627 summary
->channels
= 1;
2628 summary
->frequency
= 8000;
2630 else if( lsmash_check_codec_type_identical( audio
->type
, ISOM_CODEC_TYPE_SAWB_AUDIO
) )
2632 summary
->channels
= 1;
2633 summary
->frequency
= 16000;
2635 uint32_t actual_sampling_rate
= 0;
2636 for( lsmash_entry_t
*entry
= audio
->extensions
.head
; entry
; entry
= entry
->next
)
2638 isom_box_t
*box
= (isom_box_t
*)entry
->data
;
2641 if( !(box
->manager
& LSMASH_BINARY_CODED_BOX
) )
2643 if( lsmash_check_box_type_identical( box
->type
, QT_BOX_TYPE_CHAN
) )
2645 lsmash_codec_specific_t
*specific
= lsmash_create_codec_specific_data( LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_AUDIO_CHANNEL_LAYOUT
,
2646 LSMASH_CODEC_SPECIFIC_FORMAT_STRUCTURED
);
2649 isom_chan_t
*chan
= (isom_chan_t
*)box
;
2650 lsmash_qt_audio_channel_layout_t
*data
= (lsmash_qt_audio_channel_layout_t
*)specific
->data
.structured
;
2651 data
->channelLayoutTag
= chan
->channelLayoutTag
;
2652 data
->channelBitmap
= chan
->channelBitmap
;
2653 if( lsmash_add_entry( &summary
->opaque
->list
, specific
) < 0 )
2655 lsmash_destroy_codec_specific_data( specific
);
2659 else if( lsmash_check_box_type_identical( box
->type
, ISOM_BOX_TYPE_ESDS
)
2660 || lsmash_check_box_type_identical( box
->type
, QT_BOX_TYPE_ESDS
) )
2662 isom_esds_t
*esds
= (isom_esds_t
*)box
;
2663 if( mp4sys_setup_summary_from_DecoderSpecificInfo( summary
, esds
->ES
) < 0
2664 || isom_append_structured_mp4sys_decoder_config( summary
->opaque
, esds
) < 0 )
2667 else if( lsmash_check_box_type_identical( box
->type
, ISOM_BOX_TYPE_SRAT
) )
2669 isom_srat_t
*srat
= (isom_srat_t
*)box
;
2670 actual_sampling_rate
= srat
->sampling_rate
;
2672 else if( lsmash_check_box_type_identical( box
->type
, QT_BOX_TYPE_WAVE
) )
2674 /* Don't append 'wave' extension itself to the opaque CODEC specific info list. */
2675 isom_wave_t
*wave
= (isom_wave_t
*)box
;
2676 lsmash_bs_t
*bs
= lsmash_bs_create();
2679 for( lsmash_entry_t
*wave_entry
= wave
->extensions
.head
; wave_entry
; wave_entry
= wave_entry
->next
)
2681 isom_box_t
*wave_ext
= (isom_box_t
*)wave_entry
->data
;
2684 lsmash_box_type_t box_type
= LSMASH_BOX_TYPE_INITIALIZER
;
2685 if( !(wave_ext
->manager
& LSMASH_BINARY_CODED_BOX
) )
2687 box_type
= wave_ext
->type
;
2688 if( lsmash_check_box_type_identical( box_type
, QT_BOX_TYPE_ENDA
) )
2690 isom_enda_t
*enda
= (isom_enda_t
*)wave_ext
;
2691 isom_bs_put_box_common( bs
, enda
);
2692 lsmash_bs_put_be16( bs
, enda
->littleEndian
);
2694 else if( lsmash_check_box_type_identical( box_type
, QT_BOX_TYPE_MP4A
) )
2696 isom_mp4a_t
*mp4a
= (isom_mp4a_t
*)wave_ext
;
2697 isom_bs_put_box_common( bs
, mp4a
);
2698 lsmash_bs_put_be32( bs
, mp4a
->unknown
);
2700 else if( lsmash_check_box_type_identical( box_type
, QT_BOX_TYPE_CHAN
) )
2702 isom_chan_t
*chan
= (isom_chan_t
*)wave_ext
;
2703 isom_bs_put_box_common( bs
, chan
);
2704 lsmash_bs_put_be32( bs
, chan
->channelLayoutTag
);
2705 lsmash_bs_put_be32( bs
, chan
->channelBitmap
);
2706 lsmash_bs_put_be32( bs
, chan
->numberChannelDescriptions
);
2707 if( chan
->channelDescriptions
)
2708 for( uint32_t i
= 0; i
< chan
->numberChannelDescriptions
; i
++ )
2710 isom_channel_description_t
*channelDescriptions
= (isom_channel_description_t
*)(&chan
->channelDescriptions
[i
]);
2711 lsmash_bs_put_be32( bs
, channelDescriptions
->channelLabel
);
2712 lsmash_bs_put_be32( bs
, channelDescriptions
->channelFlags
);
2713 lsmash_bs_put_be32( bs
, channelDescriptions
->coordinates
[0] );
2714 lsmash_bs_put_be32( bs
, channelDescriptions
->coordinates
[1] );
2715 lsmash_bs_put_be32( bs
, channelDescriptions
->coordinates
[2] );
2718 else if( lsmash_check_box_type_identical( box_type
, QT_BOX_TYPE_ESDS
) )
2720 isom_esds_t
*esds
= (isom_esds_t
*)wave_ext
;
2722 || mp4sys_setup_summary_from_DecoderSpecificInfo( summary
, esds
->ES
) < 0
2723 || isom_append_structured_mp4sys_decoder_config( summary
->opaque
, esds
) < 0 )
2725 lsmash_bs_cleanup( bs
);
2731 /* Skip Format Box and Terminator Box since they are mandatory and fixed structure. */
2736 if( wave_ext
->size
< ISOM_BASEBOX_COMMON_SIZE
)
2738 uint8_t *data
= wave_ext
->binary
;
2739 box_type
.fourcc
= LSMASH_4CC( data
[4], data
[5], data
[6], data
[7] );
2740 lsmash_bs_put_bytes( bs
, wave_ext
->size
, wave_ext
->binary
);
2742 /* Export as binary string. */
2744 uint8_t *box_data
= lsmash_bs_export_data( bs
, &box_size
);
2745 lsmash_bs_empty( bs
);
2748 lsmash_bs_cleanup( bs
);
2751 /* Append as an unstructured CODEC specific info. */
2752 lsmash_codec_specific_data_type type
;
2753 if( box_type
.fourcc
== QT_BOX_TYPE_CHAN
.fourcc
)
2754 /* Complete audio channel layout is stored as binary string.
2755 * We distinguish it from one of the outside of 'wave' extension here. */
2756 type
= LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_AUDIO_DECOMPRESSION_PARAMETERS
;
2759 type
= isom_get_codec_specific_data_type( box_type
.fourcc
);
2760 if( type
== LSMASH_CODEC_SPECIFIC_DATA_TYPE_UNKNOWN
)
2761 type
= LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_AUDIO_DECOMPRESSION_PARAMETERS
;
2763 lsmash_codec_specific_t
*specific
= lsmash_create_codec_specific_data( type
, LSMASH_CODEC_SPECIFIC_FORMAT_UNSTRUCTURED
);
2766 lsmash_free( box_data
);
2767 lsmash_bs_cleanup( bs
);
2770 specific
->data
.unstructured
= box_data
;
2771 specific
->size
= box_size
;
2772 if( lsmash_add_entry( &summary
->opaque
->list
, specific
) < 0 )
2774 lsmash_destroy_codec_specific_data( specific
);
2775 lsmash_bs_cleanup( bs
);
2779 lsmash_bs_cleanup( bs
);
2784 if( box
->size
< ISOM_BASEBOX_COMMON_SIZE
)
2786 uint8_t *data
= box
->binary
;
2787 lsmash_compact_box_type_t fourcc
= LSMASH_4CC( data
[4], data
[5], data
[6], data
[7] );
2788 lsmash_codec_specific_data_type type
= isom_get_codec_specific_data_type( fourcc
);
2789 lsmash_codec_specific_t
*specific
= lsmash_create_codec_specific_data( type
, LSMASH_CODEC_SPECIFIC_FORMAT_UNSTRUCTURED
);
2792 specific
->size
= box
->size
;
2793 specific
->data
.unstructured
= lsmash_memdup( box
->binary
, box
->size
);
2794 if( !specific
->data
.unstructured
2795 || lsmash_add_entry( &summary
->opaque
->list
, specific
) < 0 )
2797 lsmash_destroy_codec_specific_data( specific
);
2800 if( specific
->type
== LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_AUDIO_DTS
2801 || specific
->type
== LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_AUDIO_AC_3
2802 || specific
->type
== LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_AUDIO_EC_3
)
2804 specific
= lsmash_convert_codec_specific_format( specific
, LSMASH_CODEC_SPECIFIC_FORMAT_STRUCTURED
);
2807 switch( specific
->type
)
2809 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_AUDIO_DTS
:
2811 lsmash_dts_specific_parameters_t
*param
= (lsmash_dts_specific_parameters_t
*)specific
->data
.structured
;
2812 summary
->sample_size
= param
->pcmSampleDepth
;
2813 summary
->samples_in_frame
= (summary
->frequency
* (512 << param
->FrameDuration
)) / param
->DTSSamplingFrequency
;
2816 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_AUDIO_AC_3
:
2818 lsmash_ac3_specific_parameters_t
*param
= (lsmash_ac3_specific_parameters_t
*)specific
->data
.structured
;
2819 summary
->frequency
= ac3_get_sample_rate( param
);
2820 summary
->channels
= ac3_get_channel_count( param
);
2821 summary
->samples_in_frame
= 1536;
2824 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_AUDIO_EC_3
:
2826 lsmash_eac3_specific_parameters_t
*param
= (lsmash_eac3_specific_parameters_t
*)specific
->data
.structured
;
2827 eac3_update_sample_rate( &summary
->frequency
, param
, NULL
);
2828 eac3_update_channel_count( &summary
->channels
, param
);
2829 summary
->samples_in_frame
= 1536;
2835 lsmash_destroy_codec_specific_data( specific
);
2839 /* Set the actual sampling rate. */
2840 if( actual_sampling_rate
)
2841 summary
->frequency
= actual_sampling_rate
;
2842 return (lsmash_summary_t
*)summary
;
2844 lsmash_cleanup_summary( (lsmash_summary_t
*)summary
);
2848 lsmash_codec_specific_t
*lsmash_get_codec_specific_data( lsmash_summary_t
*summary
, uint32_t extension_number
)
2850 if( !summary
|| !summary
->opaque
)
2853 for( lsmash_entry_t
*entry
= summary
->opaque
->list
.head
; entry
; entry
= entry
->next
)
2854 if( ++i
== extension_number
)
2855 return (lsmash_codec_specific_t
*)entry
->data
;
2859 uint32_t lsmash_count_codec_specific_data( lsmash_summary_t
*summary
)
2861 if( !summary
|| !summary
->opaque
)
2863 return summary
->opaque
->list
.entry_count
;
2866 int isom_compare_opaque_extensions( lsmash_summary_t
*a
, lsmash_summary_t
*b
)
2869 uint32_t in_number_of_extensions
= lsmash_count_codec_specific_data( a
);
2870 uint32_t out_number_of_extensions
= lsmash_count_codec_specific_data( b
);
2871 if( out_number_of_extensions
!= in_number_of_extensions
)
2873 uint32_t active_number_of_extensions
= in_number_of_extensions
;
2874 uint32_t identical_count
= 0;
2875 for( uint32_t j
= 1; j
<= in_number_of_extensions
; j
++ )
2877 lsmash_codec_specific_t
*in_cs_orig
= lsmash_get_codec_specific_data( a
, j
);
2878 lsmash_codec_specific_t
*in_cs
;
2879 lsmash_codec_specific_format compare_format
= LSMASH_CODEC_SPECIFIC_FORMAT_UNSTRUCTURED
;
2880 if( in_cs_orig
->format
== LSMASH_CODEC_SPECIFIC_FORMAT_STRUCTURED
)
2882 if( in_cs_orig
->type
== LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_VIDEO_COMMON
2883 || in_cs_orig
->type
== LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_AUDIO_COMMON
2884 || in_cs_orig
->type
== LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_AUDIO_FORMAT_SPECIFIC_FLAGS
)
2886 compare_format
= LSMASH_CODEC_SPECIFIC_FORMAT_STRUCTURED
;
2891 in_cs
= lsmash_convert_codec_specific_format( in_cs_orig
, LSMASH_CODEC_SPECIFIC_FORMAT_UNSTRUCTURED
);
2894 /* We don't support the format converter of this data type. */
2895 --active_number_of_extensions
;
2902 for( uint32_t k
= 1; k
<= out_number_of_extensions
; k
++ )
2904 lsmash_codec_specific_t
*out_cs_orig
= lsmash_get_codec_specific_data( b
, k
);
2905 if( out_cs_orig
->type
!= in_cs_orig
->type
)
2907 lsmash_codec_specific_t
*out_cs
;
2908 if( out_cs_orig
->format
== LSMASH_CODEC_SPECIFIC_FORMAT_STRUCTURED
)
2910 if( compare_format
== LSMASH_CODEC_SPECIFIC_FORMAT_STRUCTURED
)
2911 out_cs
= out_cs_orig
;
2914 out_cs
= lsmash_convert_codec_specific_format( out_cs_orig
, LSMASH_CODEC_SPECIFIC_FORMAT_UNSTRUCTURED
);
2920 out_cs
= out_cs_orig
;
2922 if( compare_format
== LSMASH_CODEC_SPECIFIC_FORMAT_UNSTRUCTURED
)
2923 identical
= out_cs
->size
== in_cs
->size
&& !memcmp( out_cs
->data
.unstructured
, in_cs
->data
.unstructured
, in_cs
->size
);
2926 if( in_cs
->type
== LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_VIDEO_COMMON
)
2928 lsmash_qt_video_common_t
*in_data
= (lsmash_qt_video_common_t
*)in_cs
->data
.structured
;
2929 lsmash_qt_video_common_t
*out_data
= (lsmash_qt_video_common_t
*)out_cs
->data
.structured
;
2930 identical
= in_data
->revision_level
== out_data
->revision_level
2931 && in_data
->vendor
== out_data
->vendor
2932 && in_data
->temporalQuality
== out_data
->temporalQuality
2933 && in_data
->spatialQuality
== out_data
->spatialQuality
2934 && in_data
->horizontal_resolution
== out_data
->horizontal_resolution
2935 && in_data
->vertical_resolution
== out_data
->vertical_resolution
2936 && in_data
->dataSize
== out_data
->dataSize
2937 && in_data
->frame_count
== out_data
->frame_count
2938 && in_data
->color_table_ID
== out_data
->color_table_ID
;
2940 else if( in_cs
->type
== LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_AUDIO_COMMON
)
2942 lsmash_qt_audio_common_t
*in_data
= (lsmash_qt_audio_common_t
*)in_cs
->data
.structured
;
2943 lsmash_qt_audio_common_t
*out_data
= (lsmash_qt_audio_common_t
*)out_cs
->data
.structured
;
2944 identical
= in_data
->revision_level
== out_data
->revision_level
2945 && in_data
->vendor
== out_data
->vendor
2946 && in_data
->compression_ID
== out_data
->compression_ID
;
2950 lsmash_qt_audio_format_specific_flags_t
*in_data
= (lsmash_qt_audio_format_specific_flags_t
*)in_cs
->data
.structured
;
2951 lsmash_qt_audio_format_specific_flags_t
*out_data
= (lsmash_qt_audio_format_specific_flags_t
*)out_cs
->data
.structured
;
2952 identical
= (in_data
->format_flags
== out_data
->format_flags
);
2955 if( out_cs
!= out_cs_orig
)
2956 lsmash_destroy_codec_specific_data( out_cs
);
2963 if( in_cs
!= in_cs_orig
)
2964 lsmash_destroy_codec_specific_data( in_cs
);
2966 return (identical_count
!= active_number_of_extensions
);
2969 int isom_get_implicit_qt_fixed_comp_audio_sample_quants
2971 isom_audio_entry_t
*audio
,
2972 uint32_t *samples_per_packet
,
2973 uint32_t *constant_bytes_per_frame
,
2974 uint32_t *sample_size
2977 if( lsmash_check_codec_type_identical( audio
->type
, QT_CODEC_TYPE_MAC3_AUDIO
) )
2979 *samples_per_packet
= 6;
2980 *constant_bytes_per_frame
= 2 * audio
->channelcount
;
2983 else if( lsmash_check_codec_type_identical( audio
->type
, QT_CODEC_TYPE_MAC6_AUDIO
) )
2985 *samples_per_packet
= 6;
2986 *constant_bytes_per_frame
= audio
->channelcount
;
2989 else if( lsmash_check_codec_type_identical( audio
->type
, QT_CODEC_TYPE_ADPCM17_AUDIO
) )
2991 *samples_per_packet
= 64;
2992 *constant_bytes_per_frame
= 34 * audio
->channelcount
;
2995 else if( lsmash_check_codec_type_identical( audio
->type
, QT_CODEC_TYPE_AGSM_AUDIO
) )
2997 *samples_per_packet
= 160;
2998 *constant_bytes_per_frame
= 33;
3001 else if( lsmash_check_codec_type_identical( audio
->type
, QT_CODEC_TYPE_ALAW_AUDIO
)
3002 || lsmash_check_codec_type_identical( audio
->type
, QT_CODEC_TYPE_ULAW_AUDIO
) )
3004 *samples_per_packet
= 1;
3005 *constant_bytes_per_frame
= audio
->channelcount
;