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_V210_VIDEO
)
102 || lsmash_check_codec_type_identical( type
, QT_CODEC_TYPE_V216_VIDEO
)
103 || lsmash_check_codec_type_identical( type
, QT_CODEC_TYPE_V308_VIDEO
)
104 || lsmash_check_codec_type_identical( type
, QT_CODEC_TYPE_V408_VIDEO
)
105 || lsmash_check_codec_type_identical( type
, QT_CODEC_TYPE_V410_VIDEO
)
106 || lsmash_check_codec_type_identical( type
, QT_CODEC_TYPE_YUV2_VIDEO
)
107 || lsmash_check_codec_type_identical( type
, QT_CODEC_TYPE_WRLE_VIDEO
);
110 static int isom_is_nalff( lsmash_codec_type_t type
)
112 return lsmash_check_codec_type_identical( type
, ISOM_CODEC_TYPE_AVC1_VIDEO
)
113 || lsmash_check_codec_type_identical( type
, ISOM_CODEC_TYPE_AVC2_VIDEO
)
114 || lsmash_check_codec_type_identical( type
, ISOM_CODEC_TYPE_AVC3_VIDEO
)
115 || lsmash_check_codec_type_identical( type
, ISOM_CODEC_TYPE_AVC4_VIDEO
)
116 || lsmash_check_codec_type_identical( type
, ISOM_CODEC_TYPE_AVCP_VIDEO
)
117 || lsmash_check_codec_type_identical( type
, ISOM_CODEC_TYPE_HVC1_VIDEO
)
118 || lsmash_check_codec_type_identical( type
, ISOM_CODEC_TYPE_HEV1_VIDEO
);
121 int lsmash_convert_crop_into_clap( lsmash_crop_t crop
, uint32_t width
, uint32_t height
, lsmash_clap_t
*clap
)
123 if( !clap
|| crop
.top
.d
== 0 || crop
.bottom
.d
== 0 || crop
.left
.d
== 0 || crop
.right
.d
== 0 )
124 return LSMASH_ERR_FUNCTION_PARAM
;
125 uint64_t vertical_crop_lcm
= lsmash_get_lcm( crop
.top
.d
, crop
.bottom
.d
);
126 uint64_t horizontal_crop_lcm
= lsmash_get_lcm( crop
.left
.d
, crop
.right
.d
);
127 lsmash_rational_u64_t clap_height
;
128 lsmash_rational_u64_t clap_width
;
129 lsmash_rational_s64_t clap_horizontal_offset
;
130 lsmash_rational_s64_t clap_vertical_offset
;
131 clap_height
.d
= vertical_crop_lcm
;
132 clap_width
.d
= horizontal_crop_lcm
;
133 clap_horizontal_offset
.d
= 2 * vertical_crop_lcm
;
134 clap_vertical_offset
.d
= 2 * horizontal_crop_lcm
;
135 clap_height
.n
= height
* vertical_crop_lcm
136 - (crop
.top
.n
* (vertical_crop_lcm
/ crop
.top
.d
) + crop
.bottom
.n
* (vertical_crop_lcm
/ crop
.bottom
.d
));
137 clap_width
.n
= width
* horizontal_crop_lcm
138 - (crop
.left
.n
* (horizontal_crop_lcm
/ crop
.left
.d
) + crop
.right
.n
* (horizontal_crop_lcm
/ crop
.right
.d
));
139 clap_horizontal_offset
.n
= (int64_t)(crop
.left
.n
* (horizontal_crop_lcm
/ crop
.left
.d
))
140 - crop
.right
.n
* (horizontal_crop_lcm
/ crop
.right
.d
);
141 clap_vertical_offset
.n
= (int64_t)(crop
.top
.n
* (vertical_crop_lcm
/ crop
.top
.d
))
142 - crop
.bottom
.n
* (vertical_crop_lcm
/ crop
.bottom
.d
);
143 lsmash_reduce_fraction( &clap_height
.n
, &clap_height
.d
);
144 lsmash_reduce_fraction( &clap_width
.n
, &clap_width
.d
);
145 lsmash_reduce_fraction_su( &clap_vertical_offset
.n
, &clap_vertical_offset
.d
);
146 lsmash_reduce_fraction_su( &clap_horizontal_offset
.n
, &clap_horizontal_offset
.d
);
147 clap
->height
= (lsmash_rational_u32_t
){ clap_height
.n
, clap_height
.d
};
148 clap
->width
= (lsmash_rational_u32_t
){ clap_width
.n
, clap_width
.d
};
149 clap
->vertical_offset
= (lsmash_rational_s32_t
){ clap_vertical_offset
.n
, clap_vertical_offset
.d
};
150 clap
->horizontal_offset
= (lsmash_rational_s32_t
){ clap_horizontal_offset
.n
, clap_horizontal_offset
.d
};
154 int lsmash_convert_clap_into_crop( lsmash_clap_t clap
, uint32_t width
, uint32_t height
, lsmash_crop_t
*crop
)
156 if( !crop
|| clap
.height
.d
== 0 || clap
.vertical_offset
.d
== 0 || clap
.width
.d
== 0 || clap
.horizontal_offset
.d
== 0 )
157 return LSMASH_ERR_FUNCTION_PARAM
;
158 uint64_t clap_vertical_lcm
= lsmash_get_lcm( clap
.height
.d
, clap
.vertical_offset
.d
);
159 uint64_t clap_horizontal_lcm
= lsmash_get_lcm( clap
.width
.d
, clap
.horizontal_offset
.d
);
160 lsmash_rational_u64_t crop_top
;
161 lsmash_rational_u64_t crop_bottom
;
162 lsmash_rational_u64_t crop_left
;
163 lsmash_rational_u64_t crop_right
;
164 crop_top
.d
= 2 * clap_vertical_lcm
;
165 crop_bottom
.d
= 2 * clap_vertical_lcm
;
166 crop_left
.d
= 2 * clap_horizontal_lcm
;
167 crop_right
.d
= 2 * clap_horizontal_lcm
;
168 crop_top
.n
= (height
* crop_top
.d
- clap
.height
.n
* (crop_top
.d
/ clap
.height
.d
)) / 2
169 + clap
.vertical_offset
.n
* (crop_top
.d
/ clap
.vertical_offset
.d
);
170 crop_bottom
.n
= (height
* crop_bottom
.d
- clap
.height
.n
* (crop_bottom
.d
/ clap
.height
.d
)) / 2
171 - clap
.vertical_offset
.n
* (crop_bottom
.d
/ clap
.vertical_offset
.d
);
172 crop_left
.n
= (width
* crop_left
.d
- clap
.width
.n
* (crop_left
.d
/ clap
.width
.d
)) / 2
173 + clap
.horizontal_offset
.n
* (crop_left
.d
/ clap
.horizontal_offset
.d
);
174 crop_right
.n
= (width
* crop_right
.d
- clap
.width
.n
* (crop_right
.d
/ clap
.width
.d
)) / 2
175 - clap
.horizontal_offset
.n
* (crop_right
.d
/ clap
.horizontal_offset
.d
);
176 lsmash_reduce_fraction( &crop_top
.n
, &crop_top
.d
);
177 lsmash_reduce_fraction( &crop_bottom
.n
, &crop_bottom
.d
);
178 lsmash_reduce_fraction( &crop_left
.n
, &crop_left
.d
);
179 lsmash_reduce_fraction( &crop_right
.n
, &crop_right
.d
);
180 crop
->top
= (lsmash_rational_u32_t
){ crop_top
.n
, crop_top
.d
};
181 crop
->bottom
= (lsmash_rational_u32_t
){ crop_bottom
.n
, crop_bottom
.d
};
182 crop
->left
= (lsmash_rational_u32_t
){ crop_left
.n
, crop_left
.d
};
183 crop
->right
= (lsmash_rational_u32_t
){ crop_right
.n
, crop_right
.d
};
187 static void isom_destruct_nothing( void *data
)
192 static int isom_initialize_structured_codec_specific_data( lsmash_codec_specific_t
*specific
)
194 extern void mp4sys_destruct_decoder_config( void * );
195 extern void h264_destruct_specific_data( void * );
196 extern void hevc_destruct_specific_data( void * );
197 extern void vc1_destruct_specific_data( void * );
198 extern void dts_destruct_specific_data( void * );
199 switch( specific
->type
)
201 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_MP4SYS_DECODER_CONFIG
:
202 specific
->size
= sizeof(lsmash_mp4sys_decoder_parameters_t
);
203 specific
->destruct
= mp4sys_destruct_decoder_config
;
205 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_VIDEO_H264
:
206 specific
->size
= sizeof(lsmash_h264_specific_parameters_t
);
207 specific
->destruct
= h264_destruct_specific_data
;
209 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_VIDEO_HEVC
:
210 specific
->size
= sizeof(lsmash_hevc_specific_parameters_t
);
211 specific
->destruct
= hevc_destruct_specific_data
;
213 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_VIDEO_VC_1
:
214 specific
->size
= sizeof(lsmash_vc1_specific_parameters_t
);
215 specific
->destruct
= vc1_destruct_specific_data
;
217 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_AUDIO_AC_3
:
218 specific
->size
= sizeof(lsmash_ac3_specific_parameters_t
);
219 specific
->destruct
= lsmash_free
;
221 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_AUDIO_EC_3
:
222 specific
->size
= sizeof(lsmash_eac3_specific_parameters_t
);
223 specific
->destruct
= lsmash_free
;
225 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_AUDIO_DTS
:
226 specific
->size
= sizeof(lsmash_dts_specific_parameters_t
);
227 specific
->destruct
= dts_destruct_specific_data
;
229 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_AUDIO_ALAC
:
230 specific
->size
= sizeof(lsmash_alac_specific_parameters_t
);
231 specific
->destruct
= lsmash_free
;
233 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_VIDEO_SAMPLE_SCALE
:
234 specific
->size
= sizeof(lsmash_isom_sample_scale_t
);
235 specific
->destruct
= lsmash_free
;
237 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_VIDEO_H264_BITRATE
:
238 specific
->size
= sizeof(lsmash_h264_bitrate_t
);
239 specific
->destruct
= lsmash_free
;
241 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_VIDEO_COMMON
:
242 specific
->size
= sizeof(lsmash_qt_video_common_t
);
243 specific
->destruct
= lsmash_free
;
245 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_AUDIO_COMMON
:
246 specific
->size
= sizeof(lsmash_qt_audio_common_t
);
247 specific
->destruct
= lsmash_free
;
249 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_AUDIO_FORMAT_SPECIFIC_FLAGS
:
250 specific
->size
= sizeof(lsmash_qt_audio_format_specific_flags_t
);
251 specific
->destruct
= lsmash_free
;
253 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_CODEC_GLOBAL_HEADER
:
254 specific
->size
= sizeof(lsmash_codec_global_header_t
);
255 specific
->destruct
= global_destruct_specific_data
;
257 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_VIDEO_FIELD_INFO
:
258 specific
->size
= sizeof(lsmash_qt_field_info_t
);
259 specific
->destruct
= lsmash_free
;
261 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_VIDEO_PIXEL_FORMAT
:
262 specific
->size
= sizeof(lsmash_qt_pixel_format_t
);
263 specific
->destruct
= lsmash_free
;
265 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_VIDEO_SIGNIFICANT_BITS
:
266 specific
->size
= sizeof(lsmash_qt_significant_bits_t
);
267 specific
->destruct
= lsmash_free
;
269 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_AUDIO_CHANNEL_LAYOUT
:
270 specific
->size
= sizeof(lsmash_qt_audio_channel_layout_t
);
271 specific
->destruct
= lsmash_free
;
275 specific
->destruct
= isom_destruct_nothing
;
278 specific
->data
.structured
= lsmash_malloc_zero( specific
->size
);
279 if( !specific
->data
.structured
)
282 specific
->destruct
= NULL
;
283 return LSMASH_ERR_MEMORY_ALLOC
;
288 static inline int isom_initialize_codec_specific_data( lsmash_codec_specific_t
*specific
,
289 lsmash_codec_specific_data_type type
,
290 lsmash_codec_specific_format format
)
292 specific
->type
= type
;
293 specific
->format
= format
;
294 if( format
== LSMASH_CODEC_SPECIFIC_FORMAT_STRUCTURED
)
296 int err
= isom_initialize_structured_codec_specific_data( specific
);
302 specific
->data
.unstructured
= NULL
;
304 specific
->destruct
= (lsmash_codec_specific_destructor_t
)lsmash_free
;
309 void lsmash_destroy_codec_specific_data( lsmash_codec_specific_t
*specific
)
313 if( specific
->destruct
)
315 if( specific
->format
== LSMASH_CODEC_SPECIFIC_FORMAT_STRUCTURED
)
317 if( specific
->data
.structured
)
318 specific
->destruct( specific
->data
.structured
);
322 if( specific
->data
.unstructured
)
323 specific
->destruct( specific
->data
.unstructured
);
326 lsmash_free( specific
);
329 lsmash_codec_specific_t
*lsmash_create_codec_specific_data( lsmash_codec_specific_data_type type
, lsmash_codec_specific_format format
)
331 lsmash_codec_specific_t
*specific
= lsmash_malloc( sizeof(lsmash_codec_specific_t
) );
334 if( isom_initialize_codec_specific_data( specific
, type
, format
) < 0 )
336 lsmash_destroy_codec_specific_data( specific
);
342 static int isom_duplicate_structured_specific_data( lsmash_codec_specific_t
*dst
, lsmash_codec_specific_t
*src
)
344 extern int mp4sys_copy_decoder_config( lsmash_codec_specific_t
*, lsmash_codec_specific_t
* );
345 extern int h264_copy_codec_specific( lsmash_codec_specific_t
*, lsmash_codec_specific_t
* );
346 extern int hevc_copy_codec_specific( lsmash_codec_specific_t
*, lsmash_codec_specific_t
* );
347 extern int vc1_copy_codec_specific( lsmash_codec_specific_t
*, lsmash_codec_specific_t
* );
348 extern int dts_copy_codec_specific( lsmash_codec_specific_t
*, lsmash_codec_specific_t
* );
349 void *src_data
= src
->data
.structured
;
350 void *dst_data
= dst
->data
.structured
;
353 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_MP4SYS_DECODER_CONFIG
:
354 return mp4sys_copy_decoder_config( dst
, src
);
355 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_VIDEO_H264
:
356 return h264_copy_codec_specific( dst
, src
);
357 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_VIDEO_HEVC
:
358 return hevc_copy_codec_specific( dst
, src
);
359 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_VIDEO_VC_1
:
360 return vc1_copy_codec_specific( dst
, src
);
361 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_AUDIO_AC_3
:
362 *(lsmash_ac3_specific_parameters_t
*)dst_data
= *(lsmash_ac3_specific_parameters_t
*)src_data
;
364 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_AUDIO_EC_3
:
365 *(lsmash_eac3_specific_parameters_t
*)dst_data
= *(lsmash_eac3_specific_parameters_t
*)src_data
;
367 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_AUDIO_DTS
:
368 return dts_copy_codec_specific( dst
, src
);
369 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_AUDIO_ALAC
:
370 *(lsmash_alac_specific_parameters_t
*)dst_data
= *(lsmash_alac_specific_parameters_t
*)src_data
;
372 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_VIDEO_SAMPLE_SCALE
:
373 *(lsmash_isom_sample_scale_t
*)dst_data
= *(lsmash_isom_sample_scale_t
*)src_data
;
375 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_VIDEO_H264_BITRATE
:
376 *(lsmash_h264_bitrate_t
*)dst_data
= *(lsmash_h264_bitrate_t
*)src_data
;
378 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_VIDEO_COMMON
:
379 *(lsmash_qt_video_common_t
*)dst_data
= *(lsmash_qt_video_common_t
*)src_data
;
381 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_AUDIO_COMMON
:
382 *(lsmash_qt_audio_common_t
*)dst_data
= *(lsmash_qt_audio_common_t
*)src_data
;
384 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_AUDIO_FORMAT_SPECIFIC_FLAGS
:
385 *(lsmash_qt_audio_format_specific_flags_t
*)dst_data
= *(lsmash_qt_audio_format_specific_flags_t
*)src_data
;
387 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_CODEC_GLOBAL_HEADER
:
389 lsmash_codec_global_header_t
*src_global
= (lsmash_codec_global_header_t
*)src_data
;
390 if( src_global
->header_data
&& src_global
->header_size
)
392 lsmash_codec_global_header_t
*dst_global
= (lsmash_codec_global_header_t
*)dst_data
;
393 dst_global
->header_data
= lsmash_memdup( src_global
->header_data
, src_global
->header_size
);
394 if( !dst_global
->header_data
)
395 return LSMASH_ERR_MEMORY_ALLOC
;
396 dst_global
->header_size
= src_global
->header_size
;
400 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_VIDEO_FIELD_INFO
:
401 *(lsmash_qt_field_info_t
*)dst_data
= *(lsmash_qt_field_info_t
*)src_data
;
403 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_VIDEO_PIXEL_FORMAT
:
404 *(lsmash_qt_pixel_format_t
*)dst_data
= *(lsmash_qt_pixel_format_t
*)src_data
;
406 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_VIDEO_SIGNIFICANT_BITS
:
407 *(lsmash_qt_significant_bits_t
*)dst_data
= *(lsmash_qt_significant_bits_t
*)src_data
;
409 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_VIDEO_GAMMA_LEVEL
:
410 *(lsmash_qt_gamma_t
*)dst_data
= *(lsmash_qt_gamma_t
*)src_data
;
412 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_AUDIO_CHANNEL_LAYOUT
:
413 *(lsmash_qt_audio_channel_layout_t
*)dst_data
= *(lsmash_qt_audio_channel_layout_t
*)src_data
;
416 return LSMASH_ERR_NAMELESS
;
420 lsmash_codec_specific_t
*isom_duplicate_codec_specific_data( lsmash_codec_specific_t
*specific
)
424 lsmash_codec_specific_t
*dup
= lsmash_create_codec_specific_data( specific
->type
, specific
->format
);
427 if( specific
->format
== LSMASH_CODEC_SPECIFIC_FORMAT_STRUCTURED
)
429 if( isom_duplicate_structured_specific_data( dup
, specific
) < 0 )
431 lsmash_destroy_codec_specific_data( dup
);
437 dup
->data
.unstructured
= lsmash_memdup( specific
->data
.unstructured
, specific
->size
);
438 if( !dup
->data
.unstructured
)
440 lsmash_destroy_codec_specific_data( dup
);
444 dup
->size
= specific
->size
;
448 static size_t isom_description_read_box_common( uint8_t **p_data
, uint64_t *size
, lsmash_box_type_t
*type
)
450 uint8_t *orig
= *p_data
;
451 uint8_t *data
= *p_data
;
452 *size
= LSMASH_GET_BE32( &data
[0] );
453 type
->fourcc
= LSMASH_GET_BE32( &data
[4] );
454 data
+= ISOM_BASEBOX_COMMON_SIZE
;
457 *size
= LSMASH_GET_BE64( data
);
461 if( type
->fourcc
== ISOM_BOX_TYPE_UUID
.fourcc
)
463 type
->user
.fourcc
= LSMASH_GET_BE32( &data
[0] );
464 memcpy( type
->user
.id
, &data
[4], 12 );
469 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
)
471 if( !parent_data
|| !child_size
|| parent_size
< ISOM_BASEBOX_COMMON_SIZE
)
473 uint8_t *data
= parent_data
;
475 lsmash_box_type_t type
;
476 uint32_t offset
= isom_description_read_box_common( &data
, &size
, &type
);
477 if( size
!= parent_size
)
479 uint8_t *end
= parent_data
+ parent_size
;
480 for( uint8_t *pos
= data
; pos
+ ISOM_BASEBOX_COMMON_SIZE
<= end
; )
482 offset
= isom_description_read_box_common( &pos
, &size
, &type
);
483 if( lsmash_check_box_type_identical( type
, child_type
) )
488 pos
+= size
- offset
; /* Move to the next box. */
493 static int isom_construct_global_specific_header( lsmash_codec_specific_t
*dst
, lsmash_codec_specific_t
*src
)
495 if( src
->size
< ISOM_BASEBOX_COMMON_SIZE
)
496 return LSMASH_ERR_INVALID_DATA
;
497 lsmash_codec_global_header_t
*global
= (lsmash_codec_global_header_t
*)dst
->data
.structured
;
498 uint8_t *data
= src
->data
.unstructured
;
499 uint64_t size
= LSMASH_GET_BE32( data
);
500 data
+= ISOM_BASEBOX_COMMON_SIZE
;
501 global
->header_size
= size
- ISOM_BASEBOX_COMMON_SIZE
;
504 size
= LSMASH_GET_BE64( data
);
506 global
->header_size
-= 8;
508 if( size
!= src
->size
)
509 return LSMASH_ERR_INVALID_DATA
;
510 if( global
->header_size
)
512 global
->header_data
= lsmash_memdup( data
, global
->header_size
);
513 if( !global
->header_data
)
514 return LSMASH_ERR_MEMORY_ALLOC
;
519 static int isom_construct_audio_channel_layout( lsmash_codec_specific_t
*dst
, lsmash_codec_specific_t
*src
)
521 if( src
->size
< ISOM_FULLBOX_COMMON_SIZE
+ 12 )
522 return LSMASH_ERR_INVALID_DATA
;
523 lsmash_qt_audio_channel_layout_t
*layout
= (lsmash_qt_audio_channel_layout_t
*)dst
->data
.structured
;
524 uint8_t *data
= src
->data
.unstructured
;
525 uint64_t size
= LSMASH_GET_BE32( data
);
526 data
+= ISOM_FULLBOX_COMMON_SIZE
;
529 size
= LSMASH_GET_BE64( data
);
532 if( size
!= src
->size
)
533 return LSMASH_ERR_INVALID_DATA
;
534 layout
->channelLayoutTag
= LSMASH_GET_BE32( &data
[0] );
535 layout
->channelBitmap
= LSMASH_GET_BE32( &data
[4] );
540 static int codec_construct_qt_audio_decompression_info( lsmash_codec_specific_t
*dst
, lsmash_codec_specific_t
*src
)
542 if( src
->size
< ISOM_BASEBOX_COMMON_SIZE
)
543 return LSMASH_ERR_INVALID_DATA
;
544 uint8_t *data
= src
->data
.unstructured
;
547 uint32_t offset
= isom_description_read_box_common( &data
, &size
, &type
);
548 if( size
!= src
->size
)
549 return LSMASH_ERR_INVALID_DATA
;
550 uint8_t *end
= src
->data
.unstructured
+ src
->size
;
551 isom_wave_t
*wave
= lsmash_malloc_zero( sizeof(isom_wave_t
) );
553 return LSMASH_ERR_MEMORY_ALLOC
;
554 wave
->type
= QT_BOX_TYPE_WAVE
;
555 for( uint8_t *pos
= data
; pos
+ ISOM_BASEBOX_COMMON_SIZE
<= end
; )
557 offset
= isom_description_read_box_common( &pos
, &size
, &type
);
560 case QT_BOX_TYPE_FRMA
:
563 return LSMASH_ERR_INVALID_DATA
;
564 isom_frma_t
*frma
= isom_add_frma( wave
);
566 return LSMASH_ERR_NAMELESS
;
567 frma
->data_format
= LSMASH_GET_BE32( pos
);
571 case QT_BOX_TYPE_ENDA
:
574 return LSMASH_ERR_INVALID_DATA
;
575 isom_enda_t
*enda
= isom_add_enda( wave
);
577 return LSMASH_ERR_NAMELESS
;
578 enda
->littleEndian
= LSMASH_GET_BE16( pos
);
581 case QT_BOX_TYPE_MP4A
:
584 return LSMASH_ERR_INVALID_DATA
;
585 isom_mp4a_t
*mp4a
= isom_add_mp4a( wave
);
587 return LSMASH_ERR_NAMELESS
;
588 mp4a
->unknown
= LSMASH_GET_BE32( pos
);
592 case QT_BOX_TYPE_TERMINATOR
:
594 if( !isom_add_terminator( wave
) )
595 return LSMASH_ERR_NAMELESS
;
600 isom_unknown_box_t
*box
= lsmash_malloc_zero( sizeof(isom_unknown_box_t
) );
602 return LSMASH_ERR_MEMORY_ALLOC
;
603 isom_init_box_common( box
, wave
, type
, isom_remove_unknown_box
);
604 box
->unknown_size
= size
- offset
;
605 box
->unknown_field
= lsmash_memdup( pos
, box
->unknown_size
);
606 if( !box
->unknown_field
)
609 return LSMASH_ERR_MEMORY_ALLOC
;
611 if( lsmash_add_entry( &wave
->extensions
, box
) < 0 )
613 isom_remove_unknown_box( box
);
614 return LSMASH_ERR_MEMORY_ALLOC
;
616 pos
+= box
->unknown_size
;
625 /* structured <-> unstructured conversion might be irreversible by CODEC
626 * since structured formats we defined don't always have all contents included in unstructured data. */
627 lsmash_codec_specific_t
*lsmash_convert_codec_specific_format( lsmash_codec_specific_t
*specific
, lsmash_codec_specific_format format
)
629 if( !specific
|| format
== LSMASH_CODEC_SPECIFIC_FORMAT_UNSPECIFIED
)
631 if( format
== specific
->format
)
632 return isom_duplicate_codec_specific_data( specific
);
633 lsmash_codec_specific_t
*dst
= lsmash_create_codec_specific_data( specific
->type
, format
);
634 if( format
== LSMASH_CODEC_SPECIFIC_FORMAT_UNSTRUCTURED
)
635 /* structured -> unstructured */
636 switch( specific
->type
)
638 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_MP4SYS_DECODER_CONFIG
:
639 dst
->data
.unstructured
= lsmash_create_mp4sys_decoder_config( (lsmash_mp4sys_decoder_parameters_t
*)specific
->data
.structured
, &dst
->size
);
640 if( !dst
->data
.unstructured
)
643 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_VIDEO_H264
:
644 dst
->data
.unstructured
= lsmash_create_h264_specific_info( (lsmash_h264_specific_parameters_t
*)specific
->data
.structured
, &dst
->size
);
645 if( !dst
->data
.unstructured
)
648 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_VIDEO_HEVC
:
649 dst
->data
.unstructured
= lsmash_create_hevc_specific_info( (lsmash_hevc_specific_parameters_t
*)specific
->data
.structured
, &dst
->size
);
650 if( !dst
->data
.unstructured
)
653 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_VIDEO_VC_1
:
654 dst
->data
.unstructured
= lsmash_create_vc1_specific_info( (lsmash_vc1_specific_parameters_t
*)specific
->data
.structured
, &dst
->size
);
655 if( !dst
->data
.unstructured
)
658 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_AUDIO_AC_3
:
659 dst
->data
.unstructured
= lsmash_create_ac3_specific_info( (lsmash_ac3_specific_parameters_t
*)specific
->data
.structured
, &dst
->size
);
660 if( !dst
->data
.unstructured
)
663 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_AUDIO_EC_3
:
664 dst
->data
.unstructured
= lsmash_create_eac3_specific_info( (lsmash_eac3_specific_parameters_t
*)specific
->data
.structured
, &dst
->size
);
665 if( !dst
->data
.unstructured
)
668 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_AUDIO_DTS
:
669 dst
->data
.unstructured
= lsmash_create_dts_specific_info( (lsmash_dts_specific_parameters_t
*)specific
->data
.structured
, &dst
->size
);
670 if( !dst
->data
.unstructured
)
673 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_AUDIO_ALAC
:
674 dst
->data
.unstructured
= lsmash_create_alac_specific_info( (lsmash_alac_specific_parameters_t
*)specific
->data
.structured
, &dst
->size
);
675 if( !dst
->data
.unstructured
)
678 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_CODEC_GLOBAL_HEADER
:
680 lsmash_bs_t
*bs
= lsmash_bs_create();
683 lsmash_codec_global_header_t
*global
= specific
->data
.structured
;
684 lsmash_bs_put_be32( bs
, ISOM_BASEBOX_COMMON_SIZE
+ global
->header_size
);
685 lsmash_bs_put_be32( bs
, QT_BOX_TYPE_GLBL
.fourcc
);
686 lsmash_bs_put_bytes( bs
, global
->header_size
, global
->header_data
);
687 dst
->data
.unstructured
= lsmash_bs_export_data( bs
, &dst
->size
);
688 lsmash_bs_cleanup( bs
);
689 if( !dst
->data
.unstructured
|| dst
->size
!= (ISOM_BASEBOX_COMMON_SIZE
+ global
->header_size
) )
696 else if( format
== LSMASH_CODEC_SPECIFIC_FORMAT_STRUCTURED
)
698 /* unstructured -> structured */
699 extern int mp4sys_construct_decoder_config( lsmash_codec_specific_t
*, lsmash_codec_specific_t
* );
700 extern int h264_construct_specific_parameters( lsmash_codec_specific_t
*, lsmash_codec_specific_t
* );
701 extern int hevc_construct_specific_parameters( lsmash_codec_specific_t
*, lsmash_codec_specific_t
* );
702 extern int vc1_construct_specific_parameters( lsmash_codec_specific_t
*, lsmash_codec_specific_t
* );
703 extern int ac3_construct_specific_parameters( lsmash_codec_specific_t
*, lsmash_codec_specific_t
* );
704 extern int eac3_construct_specific_parameters( lsmash_codec_specific_t
*, lsmash_codec_specific_t
* );
705 extern int dts_construct_specific_parameters( lsmash_codec_specific_t
*, lsmash_codec_specific_t
* );
706 extern int alac_construct_specific_parameters( lsmash_codec_specific_t
*, lsmash_codec_specific_t
* );
709 lsmash_codec_specific_data_type data_type
;
710 int (*constructor
)( lsmash_codec_specific_t
*, lsmash_codec_specific_t
* );
711 } codec_specific_format_constructor_table
[] =
713 { LSMASH_CODEC_SPECIFIC_DATA_TYPE_MP4SYS_DECODER_CONFIG
, mp4sys_construct_decoder_config
},
714 { LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_VIDEO_H264
, h264_construct_specific_parameters
},
715 { LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_VIDEO_HEVC
, hevc_construct_specific_parameters
},
716 { LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_VIDEO_VC_1
, vc1_construct_specific_parameters
},
717 { LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_AUDIO_AC_3
, ac3_construct_specific_parameters
},
718 { LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_AUDIO_EC_3
, eac3_construct_specific_parameters
},
719 { LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_AUDIO_DTS
, dts_construct_specific_parameters
},
720 { LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_AUDIO_ALAC
, alac_construct_specific_parameters
},
721 { LSMASH_CODEC_SPECIFIC_DATA_TYPE_CODEC_GLOBAL_HEADER
, isom_construct_global_specific_header
},
722 { LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_AUDIO_CHANNEL_LAYOUT
, isom_construct_audio_channel_layout
},
723 { LSMASH_CODEC_SPECIFIC_DATA_TYPE_UNKNOWN
, NULL
}
725 int (*constructor
)( lsmash_codec_specific_t
*, lsmash_codec_specific_t
* ) = NULL
;
726 for( int i
= 0; codec_specific_format_constructor_table
[i
].constructor
; i
++ )
727 if( specific
->type
== codec_specific_format_constructor_table
[i
].data_type
)
729 constructor
= codec_specific_format_constructor_table
[i
].constructor
;
732 if( constructor
&& !constructor( dst
, specific
) )
736 lsmash_destroy_codec_specific_data( dst
);
740 static inline void isom_set_default_compressorname( char *compressorname
, lsmash_codec_type_t sample_type
)
742 static struct compressorname_table_tag
744 lsmash_codec_type_t type
;
746 } compressorname_table
[32] = { { LSMASH_CODEC_TYPE_INITIALIZER
, { '\0' } } };
747 if( compressorname_table
[0].name
[0] == '\0' )
750 #define ADD_COMPRESSORNAME_TABLE( type, name ) compressorname_table[i++] = (struct compressorname_table_tag){ type, name }
751 ADD_COMPRESSORNAME_TABLE( ISOM_CODEC_TYPE_AVC1_VIDEO
, "\012AVC Coding" );
752 ADD_COMPRESSORNAME_TABLE( ISOM_CODEC_TYPE_AVC2_VIDEO
, "\012AVC Coding" );
753 ADD_COMPRESSORNAME_TABLE( ISOM_CODEC_TYPE_AVC3_VIDEO
, "\012AVC Coding" );
754 ADD_COMPRESSORNAME_TABLE( ISOM_CODEC_TYPE_AVC4_VIDEO
, "\012AVC Coding" );
755 ADD_COMPRESSORNAME_TABLE( ISOM_CODEC_TYPE_AVCP_VIDEO
, "\016AVC Parameters" );
756 ADD_COMPRESSORNAME_TABLE( ISOM_CODEC_TYPE_HVC1_VIDEO
, "\013HEVC Coding" );
757 ADD_COMPRESSORNAME_TABLE( ISOM_CODEC_TYPE_HEV1_VIDEO
, "\013HEVC Coding" );
758 ADD_COMPRESSORNAME_TABLE( ISOM_CODEC_TYPE_SVC1_VIDEO
, "\012SVC Coding" );
759 ADD_COMPRESSORNAME_TABLE( ISOM_CODEC_TYPE_MVC1_VIDEO
, "\012MVC Coding" );
760 ADD_COMPRESSORNAME_TABLE( ISOM_CODEC_TYPE_MVC2_VIDEO
, "\012MVC Coding" );
761 ADD_COMPRESSORNAME_TABLE( QT_CODEC_TYPE_APCH_VIDEO
, "\023Apple ProRes 422 (HQ)" );
762 ADD_COMPRESSORNAME_TABLE( QT_CODEC_TYPE_APCN_VIDEO
, "\023Apple ProRes 422 (SD)" );
763 ADD_COMPRESSORNAME_TABLE( QT_CODEC_TYPE_APCS_VIDEO
, "\023Apple ProRes 422 (LT)" );
764 ADD_COMPRESSORNAME_TABLE( QT_CODEC_TYPE_APCO_VIDEO
, "\026Apple ProRes 422 (Proxy)" );
765 ADD_COMPRESSORNAME_TABLE( QT_CODEC_TYPE_AP4H_VIDEO
, "\019Apple ProRes 4444" );
766 ADD_COMPRESSORNAME_TABLE( QT_CODEC_TYPE_DVPP_VIDEO
, "\014DVCPRO - PAL" );
767 ADD_COMPRESSORNAME_TABLE( QT_CODEC_TYPE_DV5N_VIDEO
, "\017DVCPRO50 - NTSC" );
768 ADD_COMPRESSORNAME_TABLE( QT_CODEC_TYPE_DV5P_VIDEO
, "\016DVCPRO50 - PAL" );
769 ADD_COMPRESSORNAME_TABLE( QT_CODEC_TYPE_DVH2_VIDEO
, "\019DVCPRO HD 1080p25" );
770 ADD_COMPRESSORNAME_TABLE( QT_CODEC_TYPE_DVH3_VIDEO
, "\019DVCPRO HD 1080p30" );
771 ADD_COMPRESSORNAME_TABLE( QT_CODEC_TYPE_DVH5_VIDEO
, "\019DVCPRO HD 1080i50" );
772 ADD_COMPRESSORNAME_TABLE( QT_CODEC_TYPE_DVH6_VIDEO
, "\019DVCPRO HD 1080i60" );
773 ADD_COMPRESSORNAME_TABLE( QT_CODEC_TYPE_DVHP_VIDEO
, "\018DVCPRO HD 720p60" );
774 ADD_COMPRESSORNAME_TABLE( QT_CODEC_TYPE_DVHQ_VIDEO
, "\018DVCPRO HD 720p50" );
775 ADD_COMPRESSORNAME_TABLE( QT_CODEC_TYPE_ULRA_VIDEO
, "\017Ut Video (ULRA)" );
776 ADD_COMPRESSORNAME_TABLE( QT_CODEC_TYPE_ULRG_VIDEO
, "\017Ut Video (ULRG)" );
777 ADD_COMPRESSORNAME_TABLE( QT_CODEC_TYPE_ULY0_VIDEO
, "\017Ut Video (ULY0)" );
778 ADD_COMPRESSORNAME_TABLE( QT_CODEC_TYPE_ULY2_VIDEO
, "\017Ut Video (ULY2)" );
779 ADD_COMPRESSORNAME_TABLE( QT_CODEC_TYPE_ULH0_VIDEO
, "\017Ut Video (ULH0)" );
780 ADD_COMPRESSORNAME_TABLE( QT_CODEC_TYPE_ULH2_VIDEO
, "\017Ut Video (ULH2)" );
781 ADD_COMPRESSORNAME_TABLE( LSMASH_CODEC_TYPE_UNSPECIFIED
, { '\0' } );
782 #undef ADD_COMPRESSORNAME_TABLE
784 for( int i
= 0; compressorname_table
[i
].name
[0] != '\0'; i
++ )
785 if( lsmash_check_codec_type_identical( sample_type
, compressorname_table
[i
].type
) )
787 strcpy( compressorname
, compressorname_table
[i
].name
);
792 lsmash_codec_specific_t
*isom_get_codec_specific( lsmash_codec_specific_list_t
*opaque
, lsmash_codec_specific_data_type type
)
794 for( lsmash_entry_t
*entry
= opaque
->list
.head
; entry
; entry
= entry
->next
)
796 lsmash_codec_specific_t
*specific
= (lsmash_codec_specific_t
*)entry
->data
;
797 if( !specific
|| specific
->type
!= type
)
804 static int isom_check_valid_summary( lsmash_summary_t
*summary
)
807 return LSMASH_ERR_NAMELESS
;
809 temp_box
.type
= summary
->sample_type
;
810 temp_box
.manager
= summary
->summary_type
== LSMASH_SUMMARY_TYPE_AUDIO
? LSMASH_AUDIO_DESCRIPTION
: 0;
811 if( isom_is_lpcm_audio( &temp_box
) )
813 if( isom_get_codec_specific( summary
->opaque
, LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_AUDIO_FORMAT_SPECIFIC_FLAGS
) )
815 return LSMASH_ERR_INVALID_DATA
;
817 if( isom_is_uncompressed_ycbcr( summary
->sample_type
) )
819 if( isom_get_codec_specific( summary
->opaque
, LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_VIDEO_FIELD_INFO
) )
821 if( !lsmash_check_codec_type_identical( summary
->sample_type
, QT_CODEC_TYPE_V216_VIDEO
) )
825 return LSMASH_ERR_INVALID_DATA
;
827 lsmash_codec_type_t sample_type
= summary
->sample_type
;
828 lsmash_codec_specific_data_type required_data_type
= LSMASH_CODEC_SPECIFIC_DATA_TYPE_UNSPECIFIED
;
829 if( lsmash_check_codec_type_identical( sample_type
, ISOM_CODEC_TYPE_AVC1_VIDEO
)
830 || lsmash_check_codec_type_identical( sample_type
, ISOM_CODEC_TYPE_AVC2_VIDEO
)
831 || lsmash_check_codec_type_identical( sample_type
, ISOM_CODEC_TYPE_AVC3_VIDEO
)
832 || lsmash_check_codec_type_identical( sample_type
, ISOM_CODEC_TYPE_AVC4_VIDEO
) )
833 required_data_type
= LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_VIDEO_H264
;
834 else if( lsmash_check_codec_type_identical( sample_type
, ISOM_CODEC_TYPE_HVC1_VIDEO
)
835 || lsmash_check_codec_type_identical( sample_type
, ISOM_CODEC_TYPE_HEV1_VIDEO
) )
836 required_data_type
= LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_VIDEO_HEVC
;
837 else if( lsmash_check_codec_type_identical( sample_type
, ISOM_CODEC_TYPE_VC_1_VIDEO
) )
838 required_data_type
= LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_VIDEO_VC_1
;
839 else if( lsmash_check_codec_type_identical( sample_type
, QT_CODEC_TYPE_ULRA_VIDEO
)
840 || lsmash_check_codec_type_identical( sample_type
, QT_CODEC_TYPE_ULRG_VIDEO
)
841 || lsmash_check_codec_type_identical( sample_type
, QT_CODEC_TYPE_ULY0_VIDEO
)
842 || lsmash_check_codec_type_identical( sample_type
, QT_CODEC_TYPE_ULY2_VIDEO
)
843 || lsmash_check_codec_type_identical( sample_type
, QT_CODEC_TYPE_ULH0_VIDEO
)
844 || lsmash_check_codec_type_identical( sample_type
, QT_CODEC_TYPE_ULH2_VIDEO
) )
845 required_data_type
= LSMASH_CODEC_SPECIFIC_DATA_TYPE_CODEC_GLOBAL_HEADER
;
846 else if( lsmash_check_codec_type_identical( sample_type
, QT_CODEC_TYPE_V216_VIDEO
) )
847 required_data_type
= LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_VIDEO_SIGNIFICANT_BITS
;
848 else if( lsmash_check_codec_type_identical( sample_type
, ISOM_CODEC_TYPE_MP4V_VIDEO
)
849 || lsmash_check_codec_type_identical( sample_type
, ISOM_CODEC_TYPE_MP4A_AUDIO
)
850 || lsmash_check_codec_type_identical( sample_type
, QT_CODEC_TYPE_MP4A_AUDIO
) )
851 required_data_type
= LSMASH_CODEC_SPECIFIC_DATA_TYPE_MP4SYS_DECODER_CONFIG
;
852 else if( lsmash_check_codec_type_identical( sample_type
, ISOM_CODEC_TYPE_AC_3_AUDIO
) )
853 required_data_type
= LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_AUDIO_AC_3
;
854 else if( lsmash_check_codec_type_identical( sample_type
, ISOM_CODEC_TYPE_EC_3_AUDIO
) )
855 required_data_type
= LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_AUDIO_EC_3
;
856 else if( lsmash_check_codec_type_identical( sample_type
, ISOM_CODEC_TYPE_DTSC_AUDIO
)
857 || lsmash_check_codec_type_identical( sample_type
, ISOM_CODEC_TYPE_DTSE_AUDIO
)
858 || lsmash_check_codec_type_identical( sample_type
, ISOM_CODEC_TYPE_DTSH_AUDIO
)
859 || lsmash_check_codec_type_identical( sample_type
, ISOM_CODEC_TYPE_DTSL_AUDIO
) )
860 required_data_type
= LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_AUDIO_DTS
;
861 else if( lsmash_check_codec_type_identical( sample_type
, ISOM_CODEC_TYPE_ALAC_AUDIO
)
862 || lsmash_check_codec_type_identical( sample_type
, QT_CODEC_TYPE_ALAC_AUDIO
) )
863 required_data_type
= LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_AUDIO_ALAC
;
864 if( required_data_type
== LSMASH_CODEC_SPECIFIC_DATA_TYPE_UNSPECIFIED
)
866 return isom_get_codec_specific( summary
->opaque
, required_data_type
) ? 0 : LSMASH_ERR_INVALID_DATA
;
869 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
)
871 lsmash_box_type_t box_type
= LSMASH_BOX_TYPE_INITIALIZER
;
872 box_type
.fourcc
= fourcc
;
873 #define GUESS_VIDEO_CODEC_SPECIFIC_BOX_TYPE( codec_type, predefined_box_type ) \
874 else if( (codec_type.user.fourcc == 0 \
875 || lsmash_check_codec_type_identical( active_codec_type, codec_type )) \
876 && box_type.fourcc == predefined_box_type.fourcc ) \
877 box_type = predefined_box_type
879 GUESS_VIDEO_CODEC_SPECIFIC_BOX_TYPE( ISOM_CODEC_TYPE_AVC1_VIDEO
, ISOM_BOX_TYPE_AVCC
);
880 GUESS_VIDEO_CODEC_SPECIFIC_BOX_TYPE( ISOM_CODEC_TYPE_AVC2_VIDEO
, ISOM_BOX_TYPE_AVCC
);
881 GUESS_VIDEO_CODEC_SPECIFIC_BOX_TYPE( ISOM_CODEC_TYPE_AVC3_VIDEO
, ISOM_BOX_TYPE_AVCC
);
882 GUESS_VIDEO_CODEC_SPECIFIC_BOX_TYPE( ISOM_CODEC_TYPE_AVC4_VIDEO
, ISOM_BOX_TYPE_AVCC
);
883 GUESS_VIDEO_CODEC_SPECIFIC_BOX_TYPE( ISOM_CODEC_TYPE_AVCP_VIDEO
, ISOM_BOX_TYPE_AVCC
);
884 GUESS_VIDEO_CODEC_SPECIFIC_BOX_TYPE( ISOM_CODEC_TYPE_HVC1_VIDEO
, ISOM_BOX_TYPE_HVCC
);
885 GUESS_VIDEO_CODEC_SPECIFIC_BOX_TYPE( ISOM_CODEC_TYPE_HEV1_VIDEO
, ISOM_BOX_TYPE_HVCC
);
886 GUESS_VIDEO_CODEC_SPECIFIC_BOX_TYPE( ISOM_CODEC_TYPE_VC_1_VIDEO
, ISOM_BOX_TYPE_DVC1
);
887 GUESS_VIDEO_CODEC_SPECIFIC_BOX_TYPE( ISOM_CODEC_TYPE_MP4V_VIDEO
, ISOM_BOX_TYPE_ESDS
);
888 GUESS_VIDEO_CODEC_SPECIFIC_BOX_TYPE( LSMASH_CODEC_TYPE_UNSPECIFIED
, ISOM_BOX_TYPE_BTRT
);
889 GUESS_VIDEO_CODEC_SPECIFIC_BOX_TYPE( LSMASH_CODEC_TYPE_UNSPECIFIED
, QT_BOX_TYPE_FIEL
);
890 GUESS_VIDEO_CODEC_SPECIFIC_BOX_TYPE( LSMASH_CODEC_TYPE_UNSPECIFIED
, QT_BOX_TYPE_CSPC
);
891 GUESS_VIDEO_CODEC_SPECIFIC_BOX_TYPE( LSMASH_CODEC_TYPE_UNSPECIFIED
, QT_BOX_TYPE_SGBT
);
892 GUESS_VIDEO_CODEC_SPECIFIC_BOX_TYPE( LSMASH_CODEC_TYPE_UNSPECIFIED
, QT_BOX_TYPE_GAMA
);
893 GUESS_VIDEO_CODEC_SPECIFIC_BOX_TYPE( LSMASH_CODEC_TYPE_UNSPECIFIED
, QT_BOX_TYPE_GLBL
);
894 #undef GUESS_VIDEO_CODEC_SPECIFIC_BOX_TYPE
898 int isom_setup_visual_description( isom_stsd_t
*stsd
, lsmash_codec_type_t sample_type
, lsmash_video_summary_t
*summary
)
903 || !stsd
->parent
->parent
904 || !stsd
->parent
->parent
->parent
905 || !stsd
->parent
->parent
->parent
->parent
)
906 return LSMASH_ERR_NAMELESS
;
907 int err
= isom_check_valid_summary( (lsmash_summary_t
*)summary
);
910 isom_visual_entry_t
*visual
= isom_add_visual_description( stsd
, sample_type
);
912 return LSMASH_ERR_NAMELESS
;
913 visual
->data_reference_index
= summary
->data_ref_index
;
915 visual
->revision_level
= 0;
917 visual
->temporalQuality
= 0;
918 visual
->spatialQuality
= 0;
919 visual
->width
= (uint16_t)summary
->width
;
920 visual
->height
= (uint16_t)summary
->height
;
921 visual
->horizresolution
= 0x00480000;
922 visual
->vertresolution
= 0x00480000;
923 visual
->dataSize
= 0;
924 visual
->frame_count
= 1;
925 visual
->depth
= isom_is_qt_video( summary
->sample_type
) || isom_is_nalff( summary
->sample_type
)
926 ? summary
->depth
: 0x0018;
927 visual
->color_table_ID
= -1;
928 if( summary
->compressorname
[0] == '\0' )
929 isom_set_default_compressorname( visual
->compressorname
, sample_type
);
932 memcpy( visual
->compressorname
, summary
->compressorname
, 32 );
933 visual
->compressorname
[32] = '\0';
935 err
= LSMASH_ERR_NAMELESS
;
936 for( lsmash_entry_t
*entry
= summary
->opaque
->list
.head
; entry
; entry
= entry
->next
)
938 lsmash_codec_specific_t
*specific
= (lsmash_codec_specific_t
*)entry
->data
;
941 if( specific
->type
== LSMASH_CODEC_SPECIFIC_DATA_TYPE_UNKNOWN
942 && specific
->format
== LSMASH_CODEC_SPECIFIC_FORMAT_STRUCTURED
)
943 continue; /* LSMASH_CODEC_SPECIFIC_DATA_TYPE_UNKNOWN + LSMASH_CODEC_SPECIFIC_FORMAT_STRUCTURED is not supported. */
944 switch( specific
->type
)
946 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_VIDEO_COMMON
:
948 if( specific
->format
== LSMASH_CODEC_SPECIFIC_FORMAT_UNSTRUCTURED
)
950 lsmash_qt_video_common_t
*data
= (lsmash_qt_video_common_t
*)specific
->data
.structured
;
951 visual
->revision_level
= data
->revision_level
;
952 visual
->vendor
= data
->vendor
;
953 visual
->temporalQuality
= data
->temporalQuality
;
954 visual
->spatialQuality
= data
->spatialQuality
;
955 visual
->horizresolution
= data
->horizontal_resolution
;
956 visual
->vertresolution
= data
->vertical_resolution
;
957 visual
->dataSize
= data
->dataSize
;
958 visual
->frame_count
= data
->frame_count
;
959 visual
->color_table_ID
= data
->color_table_ID
;
960 if( data
->color_table_ID
== 0 )
962 lsmash_qt_color_table_t
*src_ct
= &data
->color_table
;
963 uint16_t element_count
= LSMASH_MIN( src_ct
->size
+ 1, 256 );
964 isom_qt_color_array_t
*dst_array
= lsmash_malloc_zero( element_count
* sizeof(isom_qt_color_array_t
) );
967 err
= LSMASH_ERR_MEMORY_ALLOC
;
970 isom_qt_color_table_t
*dst_ct
= &visual
->color_table
;
971 dst_ct
->array
= dst_array
;
972 dst_ct
->seed
= src_ct
->seed
;
973 dst_ct
->flags
= src_ct
->flags
;
974 dst_ct
->size
= src_ct
->size
;
975 for( uint16_t i
= 0; i
< element_count
; i
++ )
977 dst_array
[i
].value
= src_ct
->array
[i
].unused
;
978 dst_array
[i
].r
= src_ct
->array
[i
].r
;
979 dst_array
[i
].g
= src_ct
->array
[i
].g
;
980 dst_array
[i
].b
= src_ct
->array
[i
].b
;
985 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_VIDEO_SAMPLE_SCALE
:
987 lsmash_codec_specific_t
*cs
= lsmash_convert_codec_specific_format( specific
, LSMASH_CODEC_SPECIFIC_FORMAT_STRUCTURED
);
990 lsmash_isom_sample_scale_t
*data
= (lsmash_isom_sample_scale_t
*)cs
->data
.structured
;
991 isom_stsl_t
*stsl
= isom_add_stsl( visual
);
994 lsmash_destroy_codec_specific_data( cs
);
997 stsl
->constraint_flag
= data
->constraint_flag
;
998 stsl
->scale_method
= data
->scale_method
;
999 stsl
->display_center_x
= data
->display_center_x
;
1000 stsl
->display_center_y
= data
->display_center_y
;
1001 lsmash_destroy_codec_specific_data( cs
);
1004 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_VIDEO_H264_BITRATE
:
1006 lsmash_codec_specific_t
*cs
= lsmash_convert_codec_specific_format( specific
, LSMASH_CODEC_SPECIFIC_FORMAT_STRUCTURED
);
1009 lsmash_h264_bitrate_t
*data
= (lsmash_h264_bitrate_t
*)cs
->data
.structured
;
1010 isom_btrt_t
*btrt
= isom_add_btrt( visual
);
1013 lsmash_destroy_codec_specific_data( cs
);
1016 btrt
->bufferSizeDB
= data
->bufferSizeDB
;
1017 btrt
->maxBitrate
= data
->maxBitrate
;
1018 btrt
->avgBitrate
= data
->avgBitrate
;
1019 lsmash_destroy_codec_specific_data( cs
);
1022 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_VIDEO_FIELD_INFO
:
1024 lsmash_codec_specific_t
*cs
= lsmash_convert_codec_specific_format( specific
, LSMASH_CODEC_SPECIFIC_FORMAT_STRUCTURED
);
1027 lsmash_qt_field_info_t
*data
= (lsmash_qt_field_info_t
*)cs
->data
.structured
;
1028 isom_fiel_t
*fiel
= isom_add_fiel( visual
);
1031 lsmash_destroy_codec_specific_data( cs
);
1034 fiel
->fields
= data
->fields
;
1035 fiel
->detail
= data
->detail
;
1036 lsmash_destroy_codec_specific_data( cs
);
1039 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_VIDEO_PIXEL_FORMAT
:
1041 lsmash_codec_specific_t
*cs
= lsmash_convert_codec_specific_format( specific
, LSMASH_CODEC_SPECIFIC_FORMAT_STRUCTURED
);
1044 lsmash_qt_pixel_format_t
*data
= (lsmash_qt_pixel_format_t
*)cs
->data
.structured
;
1045 isom_cspc_t
*cspc
= isom_add_cspc( visual
);
1048 lsmash_destroy_codec_specific_data( cs
);
1051 cspc
->pixel_format
= data
->pixel_format
;
1052 lsmash_destroy_codec_specific_data( cs
);
1055 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_VIDEO_SIGNIFICANT_BITS
:
1057 lsmash_codec_specific_t
*cs
= lsmash_convert_codec_specific_format( specific
, LSMASH_CODEC_SPECIFIC_FORMAT_STRUCTURED
);
1060 lsmash_qt_significant_bits_t
*data
= (lsmash_qt_significant_bits_t
*)cs
->data
.structured
;
1061 isom_sgbt_t
*sgbt
= isom_add_sgbt( visual
);
1064 lsmash_destroy_codec_specific_data( cs
);
1067 sgbt
->significantBits
= data
->significantBits
;
1068 lsmash_destroy_codec_specific_data( cs
);
1071 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_VIDEO_GAMMA_LEVEL
:
1073 lsmash_codec_specific_t
*cs
= lsmash_convert_codec_specific_format( specific
, LSMASH_CODEC_SPECIFIC_FORMAT_STRUCTURED
);
1076 lsmash_qt_gamma_t
*data
= (lsmash_qt_gamma_t
*)cs
->data
.structured
;
1077 isom_gama_t
*gama
= isom_add_gama( visual
);
1080 lsmash_destroy_codec_specific_data( cs
);
1083 gama
->level
= data
->level
;
1084 lsmash_destroy_codec_specific_data( cs
);
1087 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_CODEC_GLOBAL_HEADER
:
1089 lsmash_codec_specific_t
*cs
= lsmash_convert_codec_specific_format( specific
, LSMASH_CODEC_SPECIFIC_FORMAT_STRUCTURED
);
1092 lsmash_codec_global_header_t
*data
= (lsmash_codec_global_header_t
*)cs
->data
.structured
;
1093 isom_glbl_t
*glbl
= isom_add_glbl( visual
);
1096 lsmash_destroy_codec_specific_data( cs
);
1099 glbl
->header_size
= data
->header_size
;
1100 glbl
->header_data
= lsmash_memdup( data
->header_data
, data
->header_size
);
1101 lsmash_destroy_codec_specific_data( cs
);
1102 if( !glbl
->header_data
)
1104 isom_remove_box_by_itself( glbl
);
1105 err
= LSMASH_ERR_MEMORY_ALLOC
;
1112 lsmash_codec_specific_t
*cs
= lsmash_convert_codec_specific_format( specific
, LSMASH_CODEC_SPECIFIC_FORMAT_UNSTRUCTURED
);
1115 if( cs
->size
< ISOM_BASEBOX_COMMON_SIZE
)
1117 lsmash_destroy_codec_specific_data( cs
);
1118 err
= LSMASH_ERR_INVALID_DATA
;
1121 uint8_t *data
= cs
->data
.unstructured
;
1122 lsmash_compact_box_type_t fourcc
= LSMASH_4CC( data
[4], data
[5], data
[6], data
[7] );
1123 lsmash_box_type_t box_type
= isom_guess_video_codec_specific_box_type( visual
->type
, fourcc
);
1124 /* Append the extension. */
1125 err
= isom_add_extension_binary( visual
, box_type
, LSMASH_BOX_PRECEDENCE_HM
, cs
->data
.unstructured
, cs
->size
);
1126 cs
->data
.unstructured
= NULL
; /* Avoid freeing the binary data of the extension. */
1127 lsmash_destroy_codec_specific_data( cs
);
1134 isom_trak_t
*trak
= (isom_trak_t
*)visual
->parent
->parent
->parent
->parent
->parent
;
1135 int qt_compatible
= trak
->file
->qt_compatible
;
1136 isom_tapt_t
*tapt
= trak
->tapt
;
1137 isom_stsl_t
*stsl
= (isom_stsl_t
*)isom_get_extension_box_format( &visual
->extensions
, ISOM_BOX_TYPE_STSL
);
1138 int set_aperture_modes
= qt_compatible
/* Track Aperture Modes is only available under QuickTime file format. */
1139 && (!stsl
|| stsl
->scale_method
== 0) /* Sample scaling method might conflict with this feature. */
1140 && tapt
&& tapt
->clef
&& tapt
->prof
&& tapt
->enof
/* Check if required boxes exist. */
1141 && ((isom_stsd_t
*)visual
->parent
)->list
.entry_count
== 1; /* Multiple sample description might conflict with this, so in that case, disable this feature. */
1142 if( !set_aperture_modes
)
1143 isom_remove_box_by_itself( trak
->tapt
);
1144 int uncompressed_ycbcr
= qt_compatible
&& isom_is_uncompressed_ycbcr( visual
->type
);
1145 /* Set up Clean Aperture. */
1146 if( set_aperture_modes
|| uncompressed_ycbcr
1147 || (summary
->clap
.width
.d
&& summary
->clap
.height
.d
&& summary
->clap
.horizontal_offset
.d
&& summary
->clap
.vertical_offset
.d
) )
1149 isom_clap_t
*clap
= isom_add_clap( visual
);
1152 if( summary
->clap
.width
.d
&& summary
->clap
.height
.d
&& summary
->clap
.horizontal_offset
.d
&& summary
->clap
.vertical_offset
.d
)
1154 clap
->cleanApertureWidthN
= summary
->clap
.width
.n
;
1155 clap
->cleanApertureWidthD
= summary
->clap
.width
.d
;
1156 clap
->cleanApertureHeightN
= summary
->clap
.height
.n
;
1157 clap
->cleanApertureHeightD
= summary
->clap
.height
.d
;
1158 clap
->horizOffN
= summary
->clap
.horizontal_offset
.n
;
1159 clap
->horizOffD
= summary
->clap
.horizontal_offset
.d
;
1160 clap
->vertOffN
= summary
->clap
.vertical_offset
.n
;
1161 clap
->vertOffD
= summary
->clap
.vertical_offset
.d
;
1165 clap
->cleanApertureWidthN
= summary
->width
;
1166 clap
->cleanApertureWidthD
= 1;
1167 clap
->cleanApertureHeightN
= summary
->height
;
1168 clap
->cleanApertureHeightD
= 1;
1169 clap
->horizOffN
= 0;
1170 clap
->horizOffD
= 1;
1175 /* Set up Pixel Aspect Ratio. */
1176 if( set_aperture_modes
|| (summary
->par_h
&& summary
->par_v
) )
1178 isom_pasp_t
*pasp
= isom_add_pasp( visual
);
1181 pasp
->hSpacing
= LSMASH_MAX( summary
->par_h
, 1 );
1182 pasp
->vSpacing
= LSMASH_MAX( summary
->par_v
, 1 );
1184 /* Set up Color Parameter. */
1185 if( uncompressed_ycbcr
1186 || summary
->color
.primaries_index
1187 || summary
->color
.transfer_index
1188 || summary
->color
.matrix_index
1189 || (trak
->file
->isom_compatible
&& summary
->color
.full_range
) )
1191 isom_colr_t
*colr
= isom_add_colr( visual
);
1194 /* Set 'nclc' to parameter type, we don't support 'prof'. */
1195 uint16_t primaries
= summary
->color
.primaries_index
;
1196 uint16_t transfer
= summary
->color
.transfer_index
;
1197 uint16_t matrix
= summary
->color
.matrix_index
;
1198 if( qt_compatible
&& !trak
->file
->isom_compatible
)
1200 colr
->manager
|= LSMASH_QTFF_BASE
;
1201 colr
->type
= QT_BOX_TYPE_COLR
;
1202 colr
->color_parameter_type
= QT_COLOR_PARAMETER_TYPE_NCLC
;
1203 colr
->primaries_index
= (primaries
== 1 || primaries
== 5 || primaries
== 6)
1204 ? primaries
: QT_PRIMARIES_INDEX_UNSPECIFIED
;
1205 colr
->transfer_function_index
= (transfer
== 1 || transfer
== 7)
1206 ? transfer
: QT_TRANSFER_INDEX_UNSPECIFIED
;
1207 colr
->matrix_index
= (matrix
== 1 || matrix
== 6 || matrix
== 7)
1208 ? matrix
: QT_MATRIX_INDEX_UNSPECIFIED
;
1212 colr
->type
= ISOM_BOX_TYPE_COLR
;
1213 colr
->color_parameter_type
= ISOM_COLOR_PARAMETER_TYPE_NCLX
;
1214 colr
->primaries_index
= (primaries
== 1 || (primaries
>= 4 && primaries
<= 7))
1215 ? primaries
: ISOM_PRIMARIES_INDEX_UNSPECIFIED
;
1216 colr
->transfer_function_index
= (transfer
== 1 || (transfer
>= 4 && transfer
<= 8) || (transfer
>= 11 && transfer
<= 13))
1217 ? transfer
: ISOM_TRANSFER_INDEX_UNSPECIFIED
;
1218 colr
->matrix_index
= (matrix
== 1 || (matrix
>= 4 && matrix
<= 8))
1219 ? matrix
: ISOM_MATRIX_INDEX_UNSPECIFIED
;
1220 colr
->full_range_flag
= summary
->color
.full_range
;
1223 /* Set up Track Apeture Modes. */
1224 if( set_aperture_modes
)
1226 uint32_t width
= visual
->width
<< 16;
1227 uint32_t height
= visual
->height
<< 16;
1228 isom_clap_t
*clap
= (isom_clap_t
*)isom_get_extension_box_format( &visual
->extensions
, ISOM_BOX_TYPE_CLAP
);
1229 isom_pasp_t
*pasp
= (isom_pasp_t
*)isom_get_extension_box_format( &visual
->extensions
, ISOM_BOX_TYPE_PASP
);
1230 double clap_width
= ((double)clap
->cleanApertureWidthN
/ clap
->cleanApertureWidthD
) * (1<<16);
1231 double clap_height
= ((double)clap
->cleanApertureHeightN
/ clap
->cleanApertureHeightD
) * (1<<16);
1232 double par
= (double)pasp
->hSpacing
/ pasp
->vSpacing
;
1235 tapt
->clef
->width
= clap_width
* par
;
1236 tapt
->clef
->height
= clap_height
;
1237 tapt
->prof
->width
= width
* par
;
1238 tapt
->prof
->height
= height
;
1242 tapt
->clef
->width
= clap_width
;
1243 tapt
->clef
->height
= clap_height
/ par
;
1244 tapt
->prof
->width
= width
;
1245 tapt
->prof
->height
= height
/ par
;
1247 tapt
->enof
->width
= width
;
1248 tapt
->enof
->height
= height
;
1252 isom_remove_box_by_itself( visual
);
1256 static int isom_append_audio_es_descriptor_extension( isom_box_t
*box
, lsmash_audio_summary_t
*summary
)
1258 uint32_t esds_size
= 0;
1259 uint8_t *esds_data
= NULL
;
1260 lsmash_codec_specific_t
*specific
= isom_get_codec_specific( summary
->opaque
, LSMASH_CODEC_SPECIFIC_DATA_TYPE_MP4SYS_DECODER_CONFIG
);
1262 return LSMASH_ERR_NAMELESS
;
1263 if( specific
->format
== LSMASH_CODEC_SPECIFIC_FORMAT_UNSTRUCTURED
)
1265 esds_size
= specific
->size
;
1266 esds_data
= lsmash_memdup( specific
->data
.unstructured
, specific
->size
);
1268 return LSMASH_ERR_MEMORY_ALLOC
;
1272 esds_data
= lsmash_create_mp4sys_decoder_config( (lsmash_mp4sys_decoder_parameters_t
*)specific
->data
.structured
, &esds_size
);
1274 return LSMASH_ERR_NAMELESS
;
1276 isom_esds_t
*esds
= isom_add_esds( box
);
1279 lsmash_free( esds_data
);
1280 return LSMASH_ERR_NAMELESS
;
1282 lsmash_bs_t bs
= { 0 };
1283 bs
.buffer
.data
= esds_data
+ ISOM_FULLBOX_COMMON_SIZE
;
1284 bs
.buffer
.alloc
= esds_size
- ISOM_FULLBOX_COMMON_SIZE
;
1285 bs
.buffer
.store
= bs
.buffer
.alloc
;
1286 esds
->ES
= mp4sys_get_descriptor( &bs
, NULL
);
1287 lsmash_free( esds_data
);
1290 isom_remove_box_by_itself( esds
);
1291 return LSMASH_ERR_NAMELESS
;
1296 static int isom_append_channel_layout_extension( lsmash_codec_specific_t
*specific
, void *parent
, uint32_t channels
)
1299 if( isom_get_extension_box( &((isom_box_t
*)parent
)->extensions
, QT_BOX_TYPE_CHAN
) )
1300 return 0; /* Audio Channel Layout Box is already present. */
1301 lsmash_codec_specific_t
*cs
= lsmash_convert_codec_specific_format( specific
, LSMASH_CODEC_SPECIFIC_FORMAT_STRUCTURED
);
1303 return LSMASH_ERR_NAMELESS
;
1304 lsmash_qt_audio_channel_layout_t
*data
= (lsmash_qt_audio_channel_layout_t
*)cs
->data
.structured
;
1305 lsmash_channel_layout_tag channelLayoutTag
= data
->channelLayoutTag
;
1306 lsmash_channel_bitmap channelBitmap
= data
->channelBitmap
;
1307 if( channelLayoutTag
== QT_CHANNEL_LAYOUT_USE_CHANNEL_DESCRIPTIONS
/* We don't support the feature of Channel Descriptions. */
1308 || (channelLayoutTag
== QT_CHANNEL_LAYOUT_USE_CHANNEL_BITMAP
&& (!channelBitmap
|| channelBitmap
> QT_CHANNEL_BIT_FULL
)) )
1310 channelLayoutTag
= QT_CHANNEL_LAYOUT_UNKNOWN
| channels
;
1313 lsmash_destroy_codec_specific_data( cs
);
1314 /* Don't create Audio Channel Layout Box if the channel layout is unknown. */
1315 if( (channelLayoutTag
^ QT_CHANNEL_LAYOUT_UNKNOWN
) >> 16 )
1317 isom_chan_t
*chan
= isom_add_chan( parent
);
1319 return LSMASH_ERR_NAMELESS
;
1320 chan
->channelLayoutTag
= channelLayoutTag
;
1321 chan
->channelBitmap
= channelBitmap
;
1322 chan
->numberChannelDescriptions
= 0;
1323 chan
->channelDescriptions
= NULL
;
1328 static int isom_set_qtff_mp4a_description( isom_audio_entry_t
*audio
, lsmash_audio_summary_t
*summary
)
1330 isom_wave_t
*wave
= isom_add_wave( audio
);
1332 if( !(frma
= isom_add_frma( wave
))
1333 || !isom_add_mp4a( wave
)
1334 || !isom_add_terminator( wave
) )
1336 lsmash_remove_entry_tail( &audio
->extensions
, wave
->destruct
);
1337 return LSMASH_ERR_NAMELESS
;
1339 frma
->data_format
= audio
->type
.fourcc
;
1340 /* Add ES Descriptor Box. */
1341 int err
= isom_append_audio_es_descriptor_extension( (isom_box_t
*)wave
, summary
);
1345 audio
->type
= QT_CODEC_TYPE_MP4A_AUDIO
;
1346 audio
->version
= (summary
->channels
> 2 || summary
->frequency
> UINT16_MAX
) ? 2 : 1;
1347 audio
->channelcount
= audio
->version
== 2 ? 3 : LSMASH_MIN( summary
->channels
, 2 );
1348 audio
->samplesize
= 16;
1349 audio
->compression_ID
= QT_AUDIO_COMPRESSION_ID_VARIABLE_COMPRESSION
;
1350 audio
->packet_size
= 0;
1351 if( audio
->version
== 1 )
1353 audio
->samplerate
= summary
->frequency
<< 16;
1354 audio
->samplesPerPacket
= summary
->samples_in_frame
;
1355 audio
->bytesPerPacket
= 1; /* Apparently, this field is set to 1. */
1356 audio
->bytesPerFrame
= audio
->bytesPerPacket
* summary
->channels
;
1357 audio
->bytesPerSample
= 2;
1359 else /* audio->version == 2 */
1361 audio
->samplerate
= 0x00010000;
1362 audio
->sizeOfStructOnly
= 72;
1363 audio
->audioSampleRate
= (union {double d
; uint64_t i
;}){summary
->frequency
}.i
;
1364 audio
->numAudioChannels
= summary
->channels
;
1365 audio
->always7F000000
= 0x7F000000;
1366 audio
->constBitsPerChannel
= 0; /* compressed audio */
1367 audio
->formatSpecificFlags
= 0;
1368 audio
->constBytesPerAudioPacket
= 0; /* variable */
1369 audio
->constLPCMFramesPerAudioPacket
= summary
->samples_in_frame
;
1374 static int isom_set_isom_mp4a_description( isom_audio_entry_t
*audio
, lsmash_audio_summary_t
*summary
)
1376 if( summary
->summary_type
!= LSMASH_SUMMARY_TYPE_AUDIO
)
1377 return LSMASH_ERR_NAMELESS
;
1378 /* Check objectTypeIndication. */
1379 lsmash_mp4sys_object_type_indication objectTypeIndication
= lsmash_mp4sys_get_object_type_indication( (lsmash_summary_t
*)summary
);
1380 switch( objectTypeIndication
)
1382 case MP4SYS_OBJECT_TYPE_Audio_ISO_14496_3
:
1383 case MP4SYS_OBJECT_TYPE_Audio_ISO_13818_7_Main_Profile
:
1384 case MP4SYS_OBJECT_TYPE_Audio_ISO_13818_7_LC_Profile
:
1385 case MP4SYS_OBJECT_TYPE_Audio_ISO_13818_7_SSR_Profile
:
1386 case MP4SYS_OBJECT_TYPE_Audio_ISO_13818_3
: /* Legacy Interface */
1387 case MP4SYS_OBJECT_TYPE_Audio_ISO_11172_3
: /* Legacy Interface */
1390 return LSMASH_ERR_NAMELESS
;
1392 /* Add ES Descriptor Box. */
1393 int err
= isom_append_audio_es_descriptor_extension( (isom_box_t
*)audio
, summary
);
1396 /* In pure mp4 file, these "template" fields shall be default values according to the spec.
1397 But not pure - hybrid with other spec - mp4 file can take other values.
1398 Which is to say, these template values shall be ignored in terms of mp4, except some object_type_indications.
1399 see 14496-14, "Template fields used". */
1400 audio
->type
= ISOM_CODEC_TYPE_MP4A_AUDIO
;
1402 audio
->revision_level
= 0;
1404 audio
->channelcount
= 2;
1405 audio
->samplesize
= 16;
1406 audio
->compression_ID
= 0;
1407 audio
->packet_size
= 0;
1408 /* WARNING: This field cannot retain frequency above 65535Hz.
1409 This is not "FIXME", I just honestly implemented what the spec says.
1410 BTW, who ever expects sampling frequency takes fixed-point decimal??? */
1411 audio
->samplerate
= summary
->frequency
<= UINT16_MAX
? summary
->frequency
<< 16 : 0;
1415 static int isom_set_qtff_lpcm_description( isom_audio_entry_t
*audio
, lsmash_audio_summary_t
*summary
)
1417 lsmash_qt_audio_format_specific_flags_t
*lpcm
= NULL
;
1418 for( lsmash_entry_t
*entry
= summary
->opaque
->list
.head
; entry
; entry
= entry
->next
)
1420 lsmash_codec_specific_t
*specific
= (lsmash_codec_specific_t
*)entry
->data
;
1423 if( specific
->type
== LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_AUDIO_FORMAT_SPECIFIC_FLAGS
1424 && specific
->format
== LSMASH_CODEC_SPECIFIC_FORMAT_STRUCTURED
)
1426 lpcm
= (lsmash_qt_audio_format_specific_flags_t
*)specific
->data
.structured
;
1431 return LSMASH_ERR_NAMELESS
;
1432 audio
->manager
|= LSMASH_QTFF_BASE
;
1433 lsmash_codec_type_t sample_type
= audio
->type
;
1434 /* Convert the sample type into 'lpcm' if the description doesn't match the format or version = 2 fields are needed. */
1435 if( (lsmash_check_codec_type_identical( sample_type
, QT_CODEC_TYPE_RAW_AUDIO
)
1436 && (summary
->sample_size
!= 8 || (lpcm
->format_flags
& QT_LPCM_FORMAT_FLAG_FLOAT
)))
1437 || (lsmash_check_codec_type_identical( sample_type
, QT_CODEC_TYPE_FL32_AUDIO
)
1438 && (summary
->sample_size
!= 32 || !(lpcm
->format_flags
& QT_LPCM_FORMAT_FLAG_FLOAT
)))
1439 || (lsmash_check_codec_type_identical( sample_type
, QT_CODEC_TYPE_FL64_AUDIO
)
1440 && (summary
->sample_size
!= 64 || !(lpcm
->format_flags
& QT_LPCM_FORMAT_FLAG_FLOAT
)))
1441 || (lsmash_check_codec_type_identical( sample_type
, QT_CODEC_TYPE_IN24_AUDIO
)
1442 && (summary
->sample_size
!= 24 || (lpcm
->format_flags
& QT_LPCM_FORMAT_FLAG_FLOAT
)))
1443 || (lsmash_check_codec_type_identical( sample_type
, QT_CODEC_TYPE_IN32_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_23NI_AUDIO
)
1446 && (summary
->sample_size
!= 32 || (lpcm
->format_flags
& QT_LPCM_FORMAT_FLAG_FLOAT
) || (lpcm
->format_flags
& QT_LPCM_FORMAT_FLAG_BIG_ENDIAN
)))
1447 || (lsmash_check_codec_type_identical( sample_type
, QT_CODEC_TYPE_SOWT_AUDIO
)
1448 && (summary
->sample_size
!= 16 || (lpcm
->format_flags
& QT_LPCM_FORMAT_FLAG_FLOAT
) || (lpcm
->format_flags
& QT_LPCM_FORMAT_FLAG_BIG_ENDIAN
)))
1449 || (lsmash_check_codec_type_identical( sample_type
, QT_CODEC_TYPE_TWOS_AUDIO
)
1450 && ((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
)))
1451 || (lsmash_check_codec_type_identical( sample_type
, QT_CODEC_TYPE_NONE_AUDIO
)
1452 && ((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
)))
1453 || (lsmash_check_codec_type_identical( sample_type
, QT_CODEC_TYPE_NOT_SPECIFIED
)
1454 && ((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
)))
1455 || (summary
->channels
> 2 || summary
->frequency
> UINT16_MAX
|| summary
->sample_size
% 8) )
1457 audio
->type
= QT_CODEC_TYPE_LPCM_AUDIO
;
1460 else if( lsmash_check_codec_type_identical( sample_type
, QT_CODEC_TYPE_LPCM_AUDIO
) )
1462 else if( summary
->sample_size
> 16
1463 || (!lsmash_check_codec_type_identical( sample_type
, QT_CODEC_TYPE_RAW_AUDIO
)
1464 && !lsmash_check_codec_type_identical( sample_type
, QT_CODEC_TYPE_TWOS_AUDIO
)
1465 && !lsmash_check_codec_type_identical( sample_type
, QT_CODEC_TYPE_NONE_AUDIO
)
1466 && !lsmash_check_codec_type_identical( sample_type
, QT_CODEC_TYPE_NOT_SPECIFIED
)) )
1468 /* Set up constBytesPerAudioPacket field.
1469 * We use constBytesPerAudioPacket as the actual size of LPCM audio frame even when version is not 2. */
1470 audio
->constBytesPerAudioPacket
= (summary
->sample_size
* summary
->channels
) / 8;
1471 /* Set up other fields in this description by its version. */
1472 if( audio
->version
== 2 )
1474 audio
->channelcount
= 3;
1475 audio
->samplesize
= 16;
1476 audio
->compression_ID
= -2;
1477 audio
->samplerate
= 0x00010000;
1478 audio
->sizeOfStructOnly
= 72;
1479 audio
->audioSampleRate
= (union {double d
; uint64_t i
;}){summary
->frequency
}.i
;
1480 audio
->numAudioChannels
= summary
->channels
;
1481 audio
->always7F000000
= 0x7F000000;
1482 audio
->constBitsPerChannel
= summary
->sample_size
;
1483 audio
->constLPCMFramesPerAudioPacket
= 1;
1484 audio
->formatSpecificFlags
= lpcm
->format_flags
;
1485 if( lsmash_check_codec_type_identical( sample_type
, QT_CODEC_TYPE_TWOS_AUDIO
) && summary
->sample_size
!= 8 )
1486 audio
->formatSpecificFlags
|= QT_LPCM_FORMAT_FLAG_BIG_ENDIAN
;
1487 if( lpcm
->format_flags
& QT_LPCM_FORMAT_FLAG_FLOAT
)
1488 audio
->formatSpecificFlags
&= ~QT_LPCM_FORMAT_FLAG_SIGNED_INTEGER
;
1489 if( lpcm
->format_flags
& QT_LPCM_FORMAT_FLAG_PACKED
)
1490 audio
->formatSpecificFlags
&= ~QT_LPCM_FORMAT_FLAG_ALIGNED_HIGH
;
1492 else if( audio
->version
== 1 )
1494 audio
->channelcount
= summary
->channels
;
1495 audio
->samplesize
= 16;
1496 /* Audio formats other than 'raw ' and 'twos' are treated as compressed audio. */
1497 if( lsmash_check_codec_type_identical( sample_type
, QT_CODEC_TYPE_RAW_AUDIO
)
1498 || lsmash_check_codec_type_identical( sample_type
, QT_CODEC_TYPE_TWOS_AUDIO
) )
1499 audio
->compression_ID
= QT_AUDIO_COMPRESSION_ID_NOT_COMPRESSED
;
1501 audio
->compression_ID
= QT_AUDIO_COMPRESSION_ID_FIXED_COMPRESSION
;
1502 audio
->samplerate
= summary
->frequency
<< 16;
1503 audio
->samplesPerPacket
= 1;
1504 audio
->bytesPerPacket
= summary
->sample_size
/ 8;
1505 audio
->bytesPerFrame
= audio
->bytesPerPacket
* summary
->channels
; /* sample_size field in stsz box is NOT used. */
1506 audio
->bytesPerSample
= 1 + (summary
->sample_size
!= 8);
1507 if( lsmash_check_codec_type_identical( sample_type
, QT_CODEC_TYPE_FL32_AUDIO
)
1508 || lsmash_check_codec_type_identical( sample_type
, QT_CODEC_TYPE_FL64_AUDIO
)
1509 || lsmash_check_codec_type_identical( sample_type
, QT_CODEC_TYPE_IN24_AUDIO
)
1510 || lsmash_check_codec_type_identical( sample_type
, QT_CODEC_TYPE_IN32_AUDIO
) )
1512 isom_wave_t
*wave
= isom_add_wave( audio
);
1515 if( !(frma
= isom_add_frma( wave
))
1516 || !(enda
= isom_add_enda( wave
))
1517 || !isom_add_terminator( wave
) )
1519 lsmash_remove_entry_tail( &audio
->extensions
, wave
->destruct
);
1520 return LSMASH_ERR_NAMELESS
;
1522 frma
->data_format
= sample_type
.fourcc
;
1523 enda
->littleEndian
= !(lpcm
->format_flags
& QT_LPCM_FORMAT_FLAG_BIG_ENDIAN
);
1526 else /* audio->version == 0 */
1528 audio
->channelcount
= summary
->channels
;
1529 audio
->samplesize
= summary
->sample_size
;
1530 audio
->compression_ID
= QT_AUDIO_COMPRESSION_ID_NOT_COMPRESSED
;
1531 audio
->samplerate
= summary
->frequency
<< 16;
1536 static int isom_set_isom_dts_description( isom_audio_entry_t
*audio
, lsmash_audio_summary_t
*summary
)
1539 audio
->revision_level
= 0;
1541 audio
->channelcount
= summary
->channels
;
1542 audio
->samplesize
= 16;
1543 audio
->compression_ID
= 0;
1544 audio
->packet_size
= 0;
1545 switch( summary
->frequency
)
1547 case 12000 : /* Invalid? (No reference in the spec) */
1552 case 384000 : /* Invalid? (No reference in the spec) */
1553 audio
->samplerate
= 48000 << 16;
1559 case 352800 : /* Invalid? (No reference in the spec) */
1560 audio
->samplerate
= 44100 << 16;
1562 case 8000 : /* Invalid? (No reference in the spec) */
1567 audio
->samplerate
= 32000 << 16;
1570 audio
->samplerate
= 0;
1576 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
)
1578 lsmash_box_type_t box_type
= LSMASH_BOX_TYPE_INITIALIZER
;
1579 box_type
.fourcc
= fourcc
;
1580 #define GUESS_AUDIO_CODEC_SPECIFIC_BOX_TYPE( codec_type, predefined_box_type ) \
1581 else if( (codec_type.user.fourcc == 0 \
1582 || lsmash_check_codec_type_identical( active_codec_type, codec_type )) \
1583 && box_type.fourcc == predefined_box_type.fourcc ) \
1584 box_type = predefined_box_type
1586 GUESS_AUDIO_CODEC_SPECIFIC_BOX_TYPE( ISOM_CODEC_TYPE_AC_3_AUDIO
, ISOM_BOX_TYPE_DAC3
);
1587 GUESS_AUDIO_CODEC_SPECIFIC_BOX_TYPE( ISOM_CODEC_TYPE_EC_3_AUDIO
, ISOM_BOX_TYPE_DEC3
);
1588 GUESS_AUDIO_CODEC_SPECIFIC_BOX_TYPE( ISOM_CODEC_TYPE_DTSC_AUDIO
, ISOM_BOX_TYPE_DDTS
);
1589 GUESS_AUDIO_CODEC_SPECIFIC_BOX_TYPE( ISOM_CODEC_TYPE_DTSE_AUDIO
, ISOM_BOX_TYPE_DDTS
);
1590 GUESS_AUDIO_CODEC_SPECIFIC_BOX_TYPE( ISOM_CODEC_TYPE_DTSH_AUDIO
, ISOM_BOX_TYPE_DDTS
);
1591 GUESS_AUDIO_CODEC_SPECIFIC_BOX_TYPE( ISOM_CODEC_TYPE_DTSL_AUDIO
, ISOM_BOX_TYPE_DDTS
);
1592 GUESS_AUDIO_CODEC_SPECIFIC_BOX_TYPE( ISOM_CODEC_TYPE_ALAC_AUDIO
, ISOM_BOX_TYPE_ALAC
);
1593 GUESS_AUDIO_CODEC_SPECIFIC_BOX_TYPE( ISOM_CODEC_TYPE_MP4A_AUDIO
, ISOM_BOX_TYPE_ESDS
);
1594 GUESS_AUDIO_CODEC_SPECIFIC_BOX_TYPE( QT_CODEC_TYPE_ALAC_AUDIO
, QT_BOX_TYPE_ALAC
);
1595 GUESS_AUDIO_CODEC_SPECIFIC_BOX_TYPE( QT_CODEC_TYPE_MP4A_AUDIO
, QT_BOX_TYPE_ESDS
);
1596 GUESS_AUDIO_CODEC_SPECIFIC_BOX_TYPE( QT_CODEC_TYPE_FULLMP3_AUDIO
, QT_CODEC_TYPE_MP3_AUDIO
);
1597 GUESS_AUDIO_CODEC_SPECIFIC_BOX_TYPE( QT_CODEC_TYPE_ADPCM2_AUDIO
, QT_CODEC_TYPE_ADPCM2_AUDIO
);
1598 GUESS_AUDIO_CODEC_SPECIFIC_BOX_TYPE( QT_CODEC_TYPE_ADPCM17_AUDIO
, QT_CODEC_TYPE_ADPCM17_AUDIO
);
1599 GUESS_AUDIO_CODEC_SPECIFIC_BOX_TYPE( QT_CODEC_TYPE_GSM49_AUDIO
, QT_CODEC_TYPE_GSM49_AUDIO
);
1600 GUESS_AUDIO_CODEC_SPECIFIC_BOX_TYPE( LSMASH_CODEC_TYPE_UNSPECIFIED
, QT_BOX_TYPE_CHAN
);
1601 GUESS_AUDIO_CODEC_SPECIFIC_BOX_TYPE( LSMASH_CODEC_TYPE_UNSPECIFIED
, QT_BOX_TYPE_GLBL
);
1602 GUESS_AUDIO_CODEC_SPECIFIC_BOX_TYPE( LSMASH_CODEC_TYPE_UNSPECIFIED
, QT_BOX_TYPE_WAVE
);
1603 #undef GUESS_AUDIO_CODEC_SPECIFIC_BOX_TYPE
1609 uint16_t wFormatTag
;
1611 uint32_t nSamplesPerSec
;
1612 uint32_t nAvgBytesPerSec
;
1613 uint16_t nBlockAlign
;
1614 uint16_t wBitsPerSample
;
1618 static lsmash_bs_t
*isom_create_waveform_audio_info
1620 wave_format_ex_t
*wfx
,
1621 lsmash_box_type_t type
1624 lsmash_bs_t
*bs
= lsmash_bs_create();
1627 lsmash_bs_put_be32( bs
, ISOM_BASEBOX_COMMON_SIZE
+ 18 + wfx
->cbSize
);
1628 lsmash_bs_put_be32( bs
, type
.fourcc
);
1629 lsmash_bs_put_le16( bs
, wfx
->wFormatTag
);
1630 lsmash_bs_put_le16( bs
, wfx
->nChannels
);
1631 lsmash_bs_put_le32( bs
, wfx
->nSamplesPerSec
);
1632 lsmash_bs_put_le32( bs
, wfx
->nAvgBytesPerSec
);
1633 lsmash_bs_put_le16( bs
, wfx
->nBlockAlign
);
1634 lsmash_bs_put_le16( bs
, wfx
->wBitsPerSample
);
1635 lsmash_bs_put_le16( bs
, wfx
->cbSize
);
1639 static int isom_setup_waveform_audio_info
1642 isom_audio_entry_t
*audio
,
1643 lsmash_audio_summary_t
*summary
,
1644 uint32_t samples_per_packet
,
1645 uint32_t bytes_per_frame
,
1646 uint32_t sample_size
1649 wave_format_ex_t wfx
;
1650 wfx
.wFormatTag
= 0x0000; /* WAVE_FORMAT_UNKNOWN */
1651 wfx
.nChannels
= summary
->channels
;
1652 wfx
.nSamplesPerSec
= summary
->frequency
;
1653 wfx
.nAvgBytesPerSec
= 0;
1654 wfx
.nBlockAlign
= bytes_per_frame
;
1655 wfx
.wBitsPerSample
= sample_size
;
1657 lsmash_bs_t
*bs
= NULL
;
1658 if( lsmash_check_codec_type_identical( audio
->type
, QT_CODEC_TYPE_ADPCM2_AUDIO
) )
1660 /* ADPCMWAVEFORMAT */
1661 wfx
.wFormatTag
= 0x0002; /* WAVE_FORMAT_ADPCM */
1663 bs
= isom_create_waveform_audio_info( &wfx
, audio
->type
);
1665 return LSMASH_ERR_MEMORY_ALLOC
;
1666 uint16_t wSamplesPerBlock
= samples_per_packet
; /* nBlockAlign * 2 / nChannels - 12 */
1667 uint16_t wNumCoef
= 7; /* Microsoft ADPCM uses just 7 coefficients. */
1672 } aCoef
[7] = { { 256, 0 }, { 512, -256 }, { 0,0 }, { 192,64 }, { 240,0 }, { 460, -208 }, { 392,-232 } };
1673 lsmash_bs_put_le16( bs
, wSamplesPerBlock
);
1674 lsmash_bs_put_le16( bs
, wNumCoef
);
1675 for( int i
= 0; i
< 7; i
++ )
1677 lsmash_bs_put_le16( bs
, aCoef
[i
].iCoef1
);
1678 lsmash_bs_put_le16( bs
, aCoef
[i
].iCoef2
);
1681 else if( lsmash_check_codec_type_identical( audio
->type
, QT_CODEC_TYPE_ADPCM17_AUDIO
) )
1683 /* IMAADPCMWAVEFORMAT */
1684 wfx
.wFormatTag
= 0x0011; /* WAVE_FORMAT_DVI_ADPCM / WAVE_FORMAT_IMA_ADPCM */
1686 bs
= isom_create_waveform_audio_info( &wfx
, audio
->type
);
1688 return LSMASH_ERR_MEMORY_ALLOC
;
1689 uint16_t wSamplesPerBlock
= samples_per_packet
;
1690 lsmash_bs_put_le16( bs
, wSamplesPerBlock
);
1692 else if( lsmash_check_codec_type_identical( audio
->type
, QT_CODEC_TYPE_GSM49_AUDIO
) )
1694 /* GSM610WAVEFORMAT */
1695 wfx
.wFormatTag
= 0x0031; /* WAVE_FORMAT_GSM610 */
1697 bs
= isom_create_waveform_audio_info( &wfx
, audio
->type
);
1699 return LSMASH_ERR_MEMORY_ALLOC
;
1700 uint16_t wSamplesPerBlock
= samples_per_packet
;
1701 lsmash_bs_put_le16( bs
, wSamplesPerBlock
);
1703 else if( lsmash_check_codec_type_identical( audio
->type
, QT_CODEC_TYPE_FULLMP3_AUDIO
)
1704 || lsmash_check_codec_type_identical( audio
->type
, QT_CODEC_TYPE_MP3_AUDIO
) )
1706 /* MPEGLAYER3WAVEFORMAT */
1707 wfx
.wFormatTag
= 0x0055; /* WAVE_FORMAT_MPEGLAYER3 */
1708 wfx
.nBlockAlign
= 1; /* ? */
1709 wfx
.wBitsPerSample
= 0; /* undefined */
1711 bs
= isom_create_waveform_audio_info( &wfx
, audio
->type
);
1713 return LSMASH_ERR_MEMORY_ALLOC
;
1714 uint16_t wID
= 1; /* MPEGLAYER3_ID_MPEG */
1715 uint32_t fdwFlags
= 0; /* We don't know whether the stream is padded or not here. */
1716 uint16_t nBlockSize
= 0; /* (144 * (bitrate / nSamplesPerSec) + padding) * nFramesPerBlock */
1717 uint16_t nFramesPerBlock
= 1; /* the number of audio frames per block */
1718 uint16_t nCodecDelay
= 0; /* Encoder delay in samples is unknown. */
1719 lsmash_bs_put_le16( bs
, wID
);
1720 lsmash_bs_put_le32( bs
, fdwFlags
);
1721 lsmash_bs_put_le16( bs
, nBlockSize
);
1722 lsmash_bs_put_le16( bs
, nFramesPerBlock
);
1723 lsmash_bs_put_le16( bs
, nCodecDelay
);
1728 return LSMASH_ERR_NAMELESS
;
1731 uint8_t *wfx_data
= lsmash_bs_export_data( bs
, &wfx_size
);
1732 lsmash_bs_cleanup( bs
);
1734 return LSMASH_ERR_NAMELESS
;
1735 if( wfx_size
!= ISOM_BASEBOX_COMMON_SIZE
+ 18 + wfx
.cbSize
)
1737 lsmash_free( wfx_data
);
1738 return LSMASH_ERR_NAMELESS
;
1740 int err
= isom_add_extension_binary( wave
, audio
->type
, LSMASH_BOX_PRECEDENCE_HM
, wfx_data
, wfx_size
);
1743 lsmash_free( wfx_data
);
1749 static int isom_set_qtff_sound_decompression_parameters
1751 isom_audio_entry_t
*audio
,
1752 lsmash_audio_summary_t
*summary
,
1753 lsmash_qt_audio_format_specific_flag
*format_flags
,
1754 uint32_t samples_per_packet
,
1755 uint32_t bytes_per_frame
,
1756 uint32_t sample_size
1759 /* A 'wave' extension itself shall be absent in the opaque CODEC specific info list.
1760 * So, create a 'wave' extension here and append it as an extension to the audio sample description. */
1761 isom_wave_t
*wave
= isom_add_wave( audio
);
1762 if( !isom_add_frma ( wave
)
1763 || !isom_add_terminator( wave
) )
1765 lsmash_remove_entry_tail( &audio
->extensions
, wave
->destruct
);
1766 return LSMASH_ERR_NAMELESS
;
1768 wave
->frma
->data_format
= audio
->type
.fourcc
;
1769 /* Append extensions from the opaque CODEC specific info list to 'wave' extension. */
1771 int waveform_audio_info_present
= 0;
1772 int requires_waveform_audio_info
= isom_is_waveform_audio( audio
->type
);
1773 for( lsmash_entry_t
*entry
= summary
->opaque
->list
.head
; entry
; entry
= entry
->next
)
1775 lsmash_codec_specific_t
*specific
= (lsmash_codec_specific_t
*)entry
->data
;
1777 return LSMASH_ERR_NAMELESS
;
1778 if( specific
->type
== LSMASH_CODEC_SPECIFIC_DATA_TYPE_UNKNOWN
1779 && specific
->format
== LSMASH_CODEC_SPECIFIC_FORMAT_STRUCTURED
)
1780 continue; /* LSMASH_CODEC_SPECIFIC_DATA_TYPE_UNKNOWN + LSMASH_CODEC_SPECIFIC_FORMAT_STRUCTURED is not supported. */
1781 switch( specific
->type
)
1783 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_AUDIO_COMMON
:
1784 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_CODEC_GLOBAL_HEADER
:
1785 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_AUDIO_FORMAT_SPECIFIC_FLAGS
:
1786 continue; /* These cannot be an extension for 'wave' extension. */
1787 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_AUDIO_CHANNEL_LAYOUT
:
1788 /* (Legacy?) ALAC might have an Audio Channel Layout Box inside 'wave' extension. */
1792 if( lsmash_check_codec_type_identical( audio
->type
, QT_CODEC_TYPE_ALAC_AUDIO
) )
1794 if( (err
= isom_append_channel_layout_extension( specific
, wave
, summary
->channels
)) < 0 )
1800 assert( specific
->format
== LSMASH_CODEC_SPECIFIC_FORMAT_UNSTRUCTURED
1801 || specific
->type
== LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_AUDIO_DECOMPRESSION_PARAMETERS
);
1802 lsmash_codec_specific_t
*cs
= lsmash_convert_codec_specific_format( specific
, LSMASH_CODEC_SPECIFIC_FORMAT_UNSTRUCTURED
);
1804 return LSMASH_ERR_NAMELESS
;
1805 if( cs
->size
< ISOM_BASEBOX_COMMON_SIZE
)
1807 lsmash_destroy_codec_specific_data( cs
);
1810 uint8_t *box_data
= cs
->data
.unstructured
;
1811 uint64_t box_size
= cs
->size
;
1812 lsmash_compact_box_type_t fourcc
= LSMASH_4CC( box_data
[4], box_data
[5], box_data
[6], box_data
[7] );
1813 if( audio
->version
== 2 && fourcc
== QT_BOX_TYPE_ENDA
.fourcc
)
1815 /* Don't append a 'enda' extension if version == 2.
1816 * Endianness is indicated in QuickTime audio format specific flags. */
1817 if( box_size
>= ISOM_BASEBOX_COMMON_SIZE
+ 2 )
1819 /* Override endianness indicated in format specific flags. */
1820 if( box_data
[9] == 1 )
1821 *format_flags
&= ~QT_AUDIO_FORMAT_FLAG_BIG_ENDIAN
;
1823 *format_flags
|= QT_AUDIO_FORMAT_FLAG_BIG_ENDIAN
;
1825 lsmash_destroy_codec_specific_data( cs
);
1828 lsmash_box_type_t box_type
= isom_guess_audio_codec_specific_box_type( audio
->type
, fourcc
);
1829 if( lsmash_check_box_type_identical( box_type
, QT_BOX_TYPE_WAVE
) )
1831 /* It is insane to appened a 'wave' extension to a 'wave' extension. */
1832 lsmash_destroy_codec_specific_data( cs
);
1835 box_type
= lsmash_form_qtff_box_type( box_type
.fourcc
);
1836 /* Determine 'precedence'. */
1837 uint64_t precedence
;
1838 if( lsmash_check_box_type_identical( box_type
, QT_BOX_TYPE_FRMA
) )
1839 precedence
= LSMASH_BOX_PRECEDENCE_QTFF_FRMA
;
1840 else if( lsmash_check_box_type_identical( box_type
, QT_BOX_TYPE_ESDS
) )
1841 precedence
= LSMASH_BOX_PRECEDENCE_QTFF_ESDS
;
1842 else if( lsmash_check_box_type_identical( box_type
, QT_BOX_TYPE_ENDA
) )
1843 precedence
= LSMASH_BOX_PRECEDENCE_QTFF_ENDA
;
1844 else if( lsmash_check_box_type_identical( box_type
, QT_BOX_TYPE_MP4A
) )
1845 precedence
= LSMASH_BOX_PRECEDENCE_QTFF_MP4A
;
1846 else if( lsmash_check_box_type_identical( box_type
, QT_BOX_TYPE_TERMINATOR
) )
1847 precedence
= LSMASH_BOX_PRECEDENCE_QTFF_TERMINATOR
;
1849 precedence
= LSMASH_BOX_PRECEDENCE_HM
;
1850 /* Append the extension. */
1851 err
= isom_add_extension_binary( wave
, box_type
, precedence
, cs
->data
.unstructured
, cs
->size
);
1852 cs
->data
.unstructured
= NULL
; /* Avoid freeing the binary data of the extension. */
1853 lsmash_destroy_codec_specific_data( cs
);
1856 if( isom_is_waveform_audio( box_type
) )
1857 waveform_audio_info_present
= 1;
1862 if( requires_waveform_audio_info
&& !waveform_audio_info_present
1863 && (err
= isom_setup_waveform_audio_info( wave
, audio
, summary
, samples_per_packet
, bytes_per_frame
, sample_size
)) < 0 )
1868 static int isom_set_qtff_template_audio_description( isom_audio_entry_t
*audio
, lsmash_audio_summary_t
*summary
)
1870 audio
->manager
|= LSMASH_QTFF_BASE
;
1871 audio
->type
= lsmash_form_qtff_box_type( audio
->type
.fourcc
);
1872 audio
->version
= (summary
->channels
> 2 || summary
->frequency
> UINT16_MAX
) ? 2 : 1;
1873 /* Try to get QuickTime audio format specific flags. */
1874 lsmash_qt_audio_format_specific_flag format_flags
= QT_AUDIO_FORMAT_FLAG_BIG_ENDIAN
;
1875 for( lsmash_entry_t
*entry
= summary
->opaque
->list
.head
; entry
; entry
= entry
->next
)
1877 lsmash_codec_specific_t
*specific
= (lsmash_codec_specific_t
*)entry
->data
;
1879 || !specific
->data
.structured
)
1881 if( specific
->type
== LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_AUDIO_FORMAT_SPECIFIC_FLAGS
1882 && specific
->format
== LSMASH_CODEC_SPECIFIC_FORMAT_STRUCTURED
)
1884 /* A format specific flags is found.
1885 * Force audio sample description version == 2. */
1886 format_flags
= ((lsmash_qt_audio_format_specific_flags_t
*)specific
->data
.structured
)->format_flags
;
1891 uint32_t samples_per_packet
;
1892 uint32_t bytes_per_frame
;
1893 uint32_t sample_size
;
1894 if( !((summary
->samples_in_frame
== 0 || summary
->bytes_per_frame
== 0 || summary
->sample_size
== 0)
1895 && isom_get_implicit_qt_fixed_comp_audio_sample_quants( audio
, &samples_per_packet
, &bytes_per_frame
, &sample_size
)) )
1897 samples_per_packet
= summary
->samples_in_frame
;
1898 bytes_per_frame
= summary
->bytes_per_frame
;
1899 sample_size
= summary
->sample_size
;
1901 if( !lsmash_check_codec_type_identical( audio
->type
, QT_CODEC_TYPE_MAC3_AUDIO
)
1902 && !lsmash_check_codec_type_identical( audio
->type
, QT_CODEC_TYPE_MAC6_AUDIO
)
1903 && !lsmash_check_codec_type_identical( audio
->type
, QT_CODEC_TYPE_AGSM_AUDIO
)
1904 && !lsmash_check_codec_type_identical( audio
->type
, QT_CODEC_TYPE_ALAW_AUDIO
)
1905 && !lsmash_check_codec_type_identical( audio
->type
, QT_CODEC_TYPE_ULAW_AUDIO
) )
1907 int err
= isom_set_qtff_sound_decompression_parameters( audio
, summary
, &format_flags
,
1908 samples_per_packet
, bytes_per_frame
, sample_size
);
1912 /* Set up common audio description fields. */
1913 audio
->samplesize
= 16;
1914 audio
->packet_size
= 0;
1915 if( audio
->version
== 2 )
1917 audio
->channelcount
= 3;
1918 audio
->compression_ID
= QT_AUDIO_COMPRESSION_ID_VARIABLE_COMPRESSION
;
1919 audio
->samplerate
= 0x00010000;
1920 audio
->sizeOfStructOnly
= 72;
1921 audio
->audioSampleRate
= (union {double d
; uint64_t i
;}){summary
->frequency
}.i
;
1922 audio
->numAudioChannels
= summary
->channels
;
1923 audio
->always7F000000
= 0x7F000000;
1924 audio
->constBitsPerChannel
= 0;
1925 audio
->constBytesPerAudioPacket
= bytes_per_frame
;
1926 audio
->constLPCMFramesPerAudioPacket
= samples_per_packet
;
1927 if( lsmash_check_codec_type_identical( audio
->type
, QT_CODEC_TYPE_ALAC_AUDIO
) )
1929 switch( sample_size
)
1932 audio
->formatSpecificFlags
= QT_ALAC_FORMAT_FLAG_16BIT_SOURCE_DATA
;
1935 audio
->formatSpecificFlags
= QT_ALAC_FORMAT_FLAG_20BIT_SOURCE_DATA
;
1938 audio
->formatSpecificFlags
= QT_ALAC_FORMAT_FLAG_24BIT_SOURCE_DATA
;
1941 audio
->formatSpecificFlags
= QT_ALAC_FORMAT_FLAG_32BIT_SOURCE_DATA
;
1949 if( format_flags
& QT_AUDIO_FORMAT_FLAG_FLOAT
)
1950 format_flags
&= ~QT_AUDIO_FORMAT_FLAG_SIGNED_INTEGER
;
1951 if( format_flags
& QT_AUDIO_FORMAT_FLAG_PACKED
)
1952 format_flags
&= ~QT_AUDIO_FORMAT_FLAG_ALIGNED_HIGH
;
1953 audio
->formatSpecificFlags
= format_flags
;
1956 else /* if( audio->version == 1 ) */
1958 audio
->channelcount
= LSMASH_MIN( summary
->channels
, 2 );
1959 audio
->compression_ID
= QT_AUDIO_COMPRESSION_ID_FIXED_COMPRESSION
;
1960 audio
->samplerate
= summary
->frequency
<< 16;
1961 audio
->samplesPerPacket
= samples_per_packet
;
1962 audio
->bytesPerPacket
= bytes_per_frame
/ summary
->channels
;
1963 audio
->bytesPerFrame
= bytes_per_frame
; /* sample_size field in stsz box is NOT used. */
1964 audio
->bytesPerSample
= 1 + (sample_size
!= 8);
1969 static void isom_set_samplerate_division_of_media_timescale( isom_audio_entry_t
*audio
, int strict
)
1971 if( audio
->parent
/* stsd */
1972 && audio
->parent
->parent
/* stbl */
1973 && audio
->parent
->parent
->parent
/* minf */
1974 && audio
->parent
->parent
->parent
->parent
/* mdia */
1975 && lsmash_check_box_type_identical( audio
->parent
->parent
->parent
->parent
->type
, ISOM_BOX_TYPE_MDIA
)
1976 && ((isom_mdia_t
*)audio
->parent
->parent
->parent
->parent
)->mdhd
)
1978 /* Make an effort to match the timescale with samplerate, or be an integer multiple of it. */
1979 uint32_t orig_timescale
= ((isom_mdia_t
*)audio
->parent
->parent
->parent
->parent
)->mdhd
->timescale
;
1980 uint32_t timescale
= orig_timescale
;
1982 while( timescale
> UINT16_MAX
&& timescale
> 1 && i
<= UINT32_MAX
)
1984 if( timescale
% i
== 0 )
1989 if( timescale
!= orig_timescale
&& strict
)
1990 lsmash_log( NULL
, LSMASH_LOG_WARNING
, "samplerate does not match the media timescale.\n" );
1991 if( timescale
<= UINT16_MAX
&& timescale
> 1 )
1993 audio
->samplerate
= timescale
<< 16;
1997 audio
->samplerate
= 0;
2000 static int isom_set_isom_template_audio_description( isom_audio_entry_t
*audio
, lsmash_audio_summary_t
*summary
)
2002 audio
->version
= 0; /* reserved */
2003 audio
->revision_level
= 0; /* reserved */
2004 audio
->vendor
= 0; /* reserved */
2005 audio
->channelcount
= 2; /* template */
2006 audio
->samplesize
= 16; /* template */
2007 audio
->compression_ID
= 0; /* pre_defined */
2008 audio
->packet_size
= 0; /* reserved */
2009 /* template : default output audio sampling rate at playback */
2010 if( summary
->frequency
<= UINT16_MAX
)
2011 audio
->samplerate
= summary
->frequency
<< 16;
2013 isom_set_samplerate_division_of_media_timescale( audio
, 0 );
2017 static int isom_set_isom_amr_audio_description( isom_audio_entry_t
*audio
, int wb
)
2019 /* For AMR-NB and AMR-WB stream, these fields are not meaningful. */
2020 audio
->version
= 0; /* always 0 */
2021 audio
->revision_level
= 0; /* always 0 */
2022 audio
->vendor
= 0; /* always 0 */
2023 audio
->channelcount
= 2; /* always 2 although the actual number of channels is always 1 */
2024 audio
->samplesize
= 16; /* always 16 */
2025 audio
->compression_ID
= 0; /* always 0 */
2026 audio
->packet_size
= 0; /* always 0 */
2027 /* Set samplerate by trying to copy from Media Header Box of this media though the
2028 * actual samplerate is 8000 Hz for AMR-NB and 16000 Hz for AMR-WB.
2029 * 3GPP and 3GPP2 has no restriction for media timescale. Therefore, users should
2030 * set suitable media timescale by themselves within the bounds of common sense. */
2031 isom_set_samplerate_division_of_media_timescale( audio
, 1 );
2032 if( audio
->samplerate
== 0 )
2033 /* Set hard-coded but correct samplerate in the CODEC level. */
2034 audio
->samplerate
= wb
? 8000 : 16000;
2038 int isom_setup_audio_description( isom_stsd_t
*stsd
, lsmash_codec_type_t sample_type
, lsmash_audio_summary_t
*summary
)
2040 if( !stsd
|| !stsd
->file
|| !summary
)
2041 return LSMASH_ERR_NAMELESS
;
2042 int err
= isom_check_valid_summary( (lsmash_summary_t
*)summary
);
2045 isom_audio_entry_t
*audio
= isom_add_audio_description( stsd
, sample_type
);
2047 return LSMASH_ERR_NAMELESS
;
2048 audio
->data_reference_index
= summary
->data_ref_index
;
2049 lsmash_file_t
*file
= stsd
->file
;
2050 lsmash_codec_type_t audio_type
= audio
->type
;
2051 if( lsmash_check_codec_type_identical( audio_type
, ISOM_CODEC_TYPE_MP4A_AUDIO
)
2052 || lsmash_check_codec_type_identical( audio_type
, QT_CODEC_TYPE_MP4A_AUDIO
) )
2054 if( (file
->ftyp
&& file
->ftyp
->major_brand
== ISOM_BRAND_TYPE_QT
)
2055 || (!file
->ftyp
&& (file
->qt_compatible
|| (file
->moov
&& !file
->moov
->iods
))) )
2056 err
= isom_set_qtff_mp4a_description( audio
, summary
);
2058 err
= isom_set_isom_mp4a_description( audio
, summary
);
2060 else if( isom_is_lpcm_audio( audio
) )
2061 err
= isom_set_qtff_lpcm_description( audio
, summary
);
2062 else if( lsmash_check_codec_type_identical( audio_type
, ISOM_CODEC_TYPE_DTSC_AUDIO
)
2063 || lsmash_check_codec_type_identical( audio_type
, ISOM_CODEC_TYPE_DTSE_AUDIO
)
2064 || lsmash_check_codec_type_identical( audio_type
, ISOM_CODEC_TYPE_DTSH_AUDIO
)
2065 || lsmash_check_codec_type_identical( audio_type
, ISOM_CODEC_TYPE_DTSL_AUDIO
) )
2066 err
= isom_set_isom_dts_description( audio
, summary
);
2067 else if( file
->qt_compatible
)
2068 err
= isom_set_qtff_template_audio_description( audio
, summary
);
2069 else if( lsmash_check_codec_type_identical( audio_type
, ISOM_CODEC_TYPE_SAMR_AUDIO
) )
2070 err
= isom_set_isom_amr_audio_description( audio
, 0 );
2071 else if( lsmash_check_codec_type_identical( audio_type
, ISOM_CODEC_TYPE_SAWB_AUDIO
) )
2072 err
= isom_set_isom_amr_audio_description( audio
, 1 );
2074 err
= isom_set_isom_template_audio_description( audio
, summary
);
2077 err
= LSMASH_ERR_NAMELESS
;
2078 /* Don't use audio_type since audio->type might have changed. */
2079 for( lsmash_entry_t
*entry
= summary
->opaque
->list
.head
; entry
; entry
= entry
->next
)
2081 lsmash_codec_specific_t
*specific
= (lsmash_codec_specific_t
*)entry
->data
;
2084 if( specific
->type
== LSMASH_CODEC_SPECIFIC_DATA_TYPE_UNKNOWN
2085 && specific
->format
== LSMASH_CODEC_SPECIFIC_FORMAT_STRUCTURED
)
2086 continue; /* LSMASH_CODEC_SPECIFIC_DATA_TYPE_UNKNOWN + LSMASH_CODEC_SPECIFIC_FORMAT_STRUCTURED is not supported. */
2087 switch( specific
->type
)
2089 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_AUDIO_COMMON
:
2091 if( specific
->format
== LSMASH_CODEC_SPECIFIC_FORMAT_UNSTRUCTURED
)
2092 continue; /* Ignore since not fatal. */
2093 lsmash_qt_audio_common_t
*data
= (lsmash_qt_audio_common_t
*)specific
->data
.structured
;
2094 audio
->revision_level
= data
->revision_level
;
2095 audio
->vendor
= data
->vendor
;
2096 if( audio
->version
== 1
2097 && !isom_is_lpcm_audio( audio
)
2098 && data
->compression_ID
!= QT_AUDIO_COMPRESSION_ID_NOT_COMPRESSED
)
2100 /* Compressed audio must not be set to QT_AUDIO_COMPRESSION_ID_NOT_COMPRESSED. */
2101 audio
->compression_ID
= data
->compression_ID
;
2102 if( audio
->compression_ID
== QT_AUDIO_COMPRESSION_ID_VARIABLE_COMPRESSION
)
2104 /* For variable compression, bytesPerPacket and bytesPerFrame are reserved and should be set to 0. */
2105 audio
->bytesPerPacket
= 0;
2106 audio
->bytesPerFrame
= 0;
2111 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_AUDIO_CHANNEL_LAYOUT
:
2113 if( !file
->qt_compatible
2114 && !lsmash_check_codec_type_identical( audio
->type
, ISOM_CODEC_TYPE_ALAC_AUDIO
)
2115 && !lsmash_check_codec_type_identical( audio
->type
, QT_CODEC_TYPE_ALAC_AUDIO
) )
2117 if( (err
= isom_append_channel_layout_extension( specific
, audio
, summary
->channels
)) < 0 )
2121 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_CODEC_GLOBAL_HEADER
:
2123 lsmash_codec_specific_t
*cs
= lsmash_convert_codec_specific_format( specific
, LSMASH_CODEC_SPECIFIC_FORMAT_STRUCTURED
);
2126 lsmash_codec_global_header_t
*data
= (lsmash_codec_global_header_t
*)cs
->data
.structured
;
2127 isom_glbl_t
*glbl
= isom_add_glbl( audio
);
2130 lsmash_destroy_codec_specific_data( cs
);
2133 glbl
->header_size
= data
->header_size
;
2134 glbl
->header_data
= lsmash_memdup( data
->header_data
, data
->header_size
);
2135 lsmash_destroy_codec_specific_data( cs
);
2136 if( !glbl
->header_data
)
2138 isom_remove_box_by_itself( glbl
);
2139 err
= LSMASH_ERR_MEMORY_ALLOC
;
2144 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_AUDIO_FORMAT_SPECIFIC_FLAGS
:
2145 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_AUDIO_DECOMPRESSION_PARAMETERS
:
2146 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_MP4SYS_DECODER_CONFIG
:
2147 break; /* shall be set up already */
2148 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_AUDIO_ALAC
:
2149 if( file
->qt_compatible
)
2150 continue; /* shall be set up already */
2153 lsmash_codec_specific_t
*cs
= lsmash_convert_codec_specific_format( specific
, LSMASH_CODEC_SPECIFIC_FORMAT_UNSTRUCTURED
);
2156 if( cs
->size
< ISOM_BASEBOX_COMMON_SIZE
)
2158 lsmash_destroy_codec_specific_data( cs
);
2161 uint8_t *box_data
= cs
->data
.unstructured
;
2162 lsmash_compact_box_type_t fourcc
= LSMASH_4CC( box_data
[4], box_data
[5], box_data
[6], box_data
[7] );
2163 lsmash_box_type_t box_type
= isom_guess_audio_codec_specific_box_type( audio
->type
, fourcc
);
2164 if( lsmash_check_box_type_identical( box_type
, QT_BOX_TYPE_WAVE
) )
2166 /* CODEC specific info shall be already inside 'wave' extension. */
2167 lsmash_destroy_codec_specific_data( cs
);
2170 /* Append the extension. */
2171 err
= isom_add_extension_binary( audio
, box_type
, LSMASH_BOX_PRECEDENCE_HM
, cs
->data
.unstructured
, cs
->size
);
2172 cs
->data
.unstructured
= NULL
; /* Avoid freeing the binary data of the extension. */
2173 lsmash_destroy_codec_specific_data( cs
);
2180 if( audio
->version
== 0 )
2181 audio
->compression_ID
= QT_AUDIO_COMPRESSION_ID_NOT_COMPRESSED
;
2182 else if( audio
->version
== 2 )
2183 audio
->compression_ID
= QT_AUDIO_COMPRESSION_ID_VARIABLE_COMPRESSION
;
2186 isom_remove_box_by_itself( audio
);
2190 int isom_setup_tx3g_description( isom_stsd_t
*stsd
, lsmash_summary_t
*summary
)
2192 isom_tx3g_entry_t
*tx3g
= isom_add_tx3g_description( stsd
);
2194 return LSMASH_ERR_NAMELESS
;
2195 /* We create a dummy font record to make valid font_ID in the sample description.
2196 * The specification (3GPP TS 26.245) does not forbid the value 0 for the identifier,
2197 * but we set 1 to it as track_ID begins from 1. */
2198 tx3g
->data_reference_index
= summary
->data_ref_index
;
2199 tx3g
->font_ID
= 1; /* ID of the default font record */
2200 int err
= LSMASH_ERR_MEMORY_ALLOC
;
2201 isom_ftab_t
*ftab
= isom_add_ftab( tx3g
);
2204 err
= LSMASH_ERR_NAMELESS
;
2207 isom_font_record_t
*font
= lsmash_malloc( sizeof(isom_font_record_t
) );
2210 if( lsmash_add_entry( ftab
->list
, font
) < 0 )
2212 lsmash_free( font
);
2215 const char font_names
[] = "Serif,Sans-serif,Monospace";
2217 font
->font_name_length
= sizeof(font_names
);
2218 font
->font_name
= lsmash_memdup( font_names
, sizeof(font_names
) );
2219 if( !font
->font_name
)
2223 isom_remove_box_by_itself( tx3g
);
2227 static lsmash_codec_specific_data_type
isom_get_codec_specific_data_type( lsmash_compact_box_type_t extension_fourcc
)
2229 static struct codec_specific_data_type_table_tag
2231 lsmash_compact_box_type_t extension_fourcc
;
2232 lsmash_codec_specific_data_type data_type
;
2233 } codec_specific_data_type_table
[32] = { { 0, LSMASH_CODEC_SPECIFIC_DATA_TYPE_UNKNOWN
} };
2234 if( codec_specific_data_type_table
[0].data_type
== LSMASH_CODEC_SPECIFIC_DATA_TYPE_UNKNOWN
)
2237 #define ADD_CODEC_SPECIFIC_DATA_TYPE_TABLE_ELEMENT( extension_type, data_type ) \
2238 codec_specific_data_type_table[i++] = (struct codec_specific_data_type_table_tag){ extension_type.fourcc, data_type }
2239 ADD_CODEC_SPECIFIC_DATA_TYPE_TABLE_ELEMENT( ISOM_BOX_TYPE_AVCC
, LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_VIDEO_H264
);
2240 ADD_CODEC_SPECIFIC_DATA_TYPE_TABLE_ELEMENT( ISOM_BOX_TYPE_HVCC
, LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_VIDEO_HEVC
);
2241 ADD_CODEC_SPECIFIC_DATA_TYPE_TABLE_ELEMENT( ISOM_BOX_TYPE_DVC1
, LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_VIDEO_VC_1
);
2242 ADD_CODEC_SPECIFIC_DATA_TYPE_TABLE_ELEMENT( ISOM_BOX_TYPE_DAC3
, LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_AUDIO_AC_3
);
2243 ADD_CODEC_SPECIFIC_DATA_TYPE_TABLE_ELEMENT( ISOM_BOX_TYPE_DEC3
, LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_AUDIO_EC_3
);
2244 ADD_CODEC_SPECIFIC_DATA_TYPE_TABLE_ELEMENT( ISOM_BOX_TYPE_DDTS
, LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_AUDIO_DTS
);
2245 ADD_CODEC_SPECIFIC_DATA_TYPE_TABLE_ELEMENT( ISOM_BOX_TYPE_ALAC
, LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_AUDIO_ALAC
);
2246 ADD_CODEC_SPECIFIC_DATA_TYPE_TABLE_ELEMENT( ISOM_BOX_TYPE_ESDS
, LSMASH_CODEC_SPECIFIC_DATA_TYPE_MP4SYS_DECODER_CONFIG
);
2247 ADD_CODEC_SPECIFIC_DATA_TYPE_TABLE_ELEMENT( ISOM_BOX_TYPE_STSL
, LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_VIDEO_SAMPLE_SCALE
);
2248 ADD_CODEC_SPECIFIC_DATA_TYPE_TABLE_ELEMENT( ISOM_BOX_TYPE_BTRT
, LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_VIDEO_H264_BITRATE
);
2249 //ADD_CODEC_SPECIFIC_DATA_TYPE_TABLE_ELEMENT( QT_BOX_TYPE_ALAC, LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_AUDIO_ALAC );
2250 //ADD_CODEC_SPECIFIC_DATA_TYPE_TABLE_ELEMENT( QT_BOX_TYPE_ESDS, LSMASH_CODEC_SPECIFIC_DATA_TYPE_MP4SYS_DECODER_CONFIG );
2251 ADD_CODEC_SPECIFIC_DATA_TYPE_TABLE_ELEMENT( QT_BOX_TYPE_FIEL
, LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_VIDEO_FIELD_INFO
);
2252 ADD_CODEC_SPECIFIC_DATA_TYPE_TABLE_ELEMENT( QT_BOX_TYPE_CSPC
, LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_VIDEO_PIXEL_FORMAT
);
2253 ADD_CODEC_SPECIFIC_DATA_TYPE_TABLE_ELEMENT( QT_BOX_TYPE_SGBT
, LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_VIDEO_SIGNIFICANT_BITS
);
2254 ADD_CODEC_SPECIFIC_DATA_TYPE_TABLE_ELEMENT( QT_BOX_TYPE_GAMA
, LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_VIDEO_GAMMA_LEVEL
);
2255 ADD_CODEC_SPECIFIC_DATA_TYPE_TABLE_ELEMENT( QT_BOX_TYPE_CHAN
, LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_AUDIO_CHANNEL_LAYOUT
);
2256 ADD_CODEC_SPECIFIC_DATA_TYPE_TABLE_ELEMENT( QT_BOX_TYPE_GLBL
, LSMASH_CODEC_SPECIFIC_DATA_TYPE_CODEC_GLOBAL_HEADER
);
2257 ADD_CODEC_SPECIFIC_DATA_TYPE_TABLE_ELEMENT( LSMASH_BOX_TYPE_UNSPECIFIED
, LSMASH_CODEC_SPECIFIC_DATA_TYPE_UNKNOWN
);
2258 #undef ADD_CODEC_SPECIFIC_DATA_TYPE_TABLE_ELEMENT
2260 lsmash_codec_specific_data_type data_type
= LSMASH_CODEC_SPECIFIC_DATA_TYPE_UNKNOWN
;
2261 for( int i
= 0; codec_specific_data_type_table
[i
].data_type
!= LSMASH_CODEC_SPECIFIC_DATA_TYPE_UNKNOWN
; i
++ )
2262 if( extension_fourcc
== codec_specific_data_type_table
[i
].extension_fourcc
)
2264 data_type
= codec_specific_data_type_table
[i
].data_type
;
2270 lsmash_summary_t
*isom_create_video_summary_from_description( isom_sample_entry_t
*sample_entry
)
2274 isom_visual_entry_t
*visual
= (isom_visual_entry_t
*)sample_entry
;
2275 lsmash_video_summary_t
*summary
= (lsmash_video_summary_t
*)lsmash_create_summary( LSMASH_SUMMARY_TYPE_VIDEO
);
2278 summary
->sample_type
= visual
->type
;
2279 summary
->data_ref_index
= visual
->data_reference_index
;
2280 summary
->width
= visual
->width
;
2281 summary
->height
= visual
->height
;
2282 summary
->depth
= visual
->depth
;
2283 memcpy( summary
->compressorname
, visual
->compressorname
, 32 );
2284 summary
->compressorname
[32] = '\0';
2285 if( isom_is_qt_video( summary
->sample_type
) )
2287 lsmash_codec_specific_t
*specific
= lsmash_create_codec_specific_data( LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_VIDEO_COMMON
,
2288 LSMASH_CODEC_SPECIFIC_FORMAT_STRUCTURED
);
2291 lsmash_qt_video_common_t
*data
= (lsmash_qt_video_common_t
*)specific
->data
.structured
;
2292 data
->revision_level
= visual
->revision_level
;
2293 data
->vendor
= visual
->vendor
;
2294 data
->temporalQuality
= visual
->temporalQuality
;
2295 data
->spatialQuality
= visual
->spatialQuality
;
2296 data
->horizontal_resolution
= visual
->horizresolution
;
2297 data
->vertical_resolution
= visual
->vertresolution
;
2298 data
->dataSize
= visual
->dataSize
;
2299 data
->frame_count
= visual
->frame_count
;
2300 data
->color_table_ID
= visual
->color_table_ID
;
2301 if( visual
->color_table_ID
== 0 )
2303 isom_qt_color_table_t
*src_ct
= &visual
->color_table
;
2304 if( !src_ct
->array
)
2306 uint16_t element_count
= LSMASH_MIN( src_ct
->size
+ 1, 256 );
2307 lsmash_qt_color_table_t
*dst_ct
= &data
->color_table
;
2308 dst_ct
->seed
= src_ct
->seed
;
2309 dst_ct
->flags
= src_ct
->flags
;
2310 dst_ct
->size
= src_ct
->size
;
2311 for( uint16_t i
= 0; i
< element_count
; i
++ )
2313 dst_ct
->array
[i
].unused
= src_ct
->array
[i
].value
;
2314 dst_ct
->array
[i
].r
= src_ct
->array
[i
].r
;
2315 dst_ct
->array
[i
].g
= src_ct
->array
[i
].g
;
2316 dst_ct
->array
[i
].b
= src_ct
->array
[i
].b
;
2319 if( lsmash_add_entry( &summary
->opaque
->list
, specific
) < 0 )
2321 lsmash_destroy_codec_specific_data( specific
);
2325 for( lsmash_entry_t
*entry
= visual
->extensions
.head
; entry
; entry
= entry
->next
)
2327 isom_box_t
*box
= (isom_box_t
*)entry
->data
;
2330 if( !(box
->manager
& LSMASH_BINARY_CODED_BOX
) )
2332 lsmash_codec_specific_t
*specific
= NULL
;
2333 if( lsmash_check_box_type_identical( box
->type
, ISOM_BOX_TYPE_CLAP
) )
2335 isom_clap_t
*clap
= (isom_clap_t
*)box
;
2336 summary
->clap
.width
.n
= clap
->cleanApertureWidthN
;
2337 summary
->clap
.width
.d
= clap
->cleanApertureWidthD
;
2338 summary
->clap
.height
.n
= clap
->cleanApertureHeightN
;
2339 summary
->clap
.height
.d
= clap
->cleanApertureHeightD
;
2340 summary
->clap
.horizontal_offset
.n
= clap
->horizOffN
;
2341 summary
->clap
.horizontal_offset
.d
= clap
->horizOffD
;
2342 summary
->clap
.vertical_offset
.n
= clap
->vertOffN
;
2343 summary
->clap
.vertical_offset
.d
= clap
->vertOffD
;
2346 else if( lsmash_check_box_type_identical( box
->type
, ISOM_BOX_TYPE_PASP
) )
2348 isom_pasp_t
*pasp
= (isom_pasp_t
*)box
;
2349 summary
->par_h
= pasp
->hSpacing
;
2350 summary
->par_v
= pasp
->vSpacing
;
2353 else if( lsmash_check_box_type_identical( box
->type
, ISOM_BOX_TYPE_COLR
)
2354 || lsmash_check_box_type_identical( box
->type
, QT_BOX_TYPE_COLR
) )
2356 isom_colr_t
*colr
= (isom_colr_t
*)box
;
2357 summary
->color
.primaries_index
= colr
->primaries_index
;
2358 summary
->color
.transfer_index
= colr
->transfer_function_index
;
2359 summary
->color
.matrix_index
= colr
->matrix_index
;
2360 summary
->color
.full_range
= colr
->full_range_flag
;
2363 else if( lsmash_check_box_type_identical( box
->type
, ISOM_BOX_TYPE_STSL
) )
2365 specific
= lsmash_create_codec_specific_data( LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_VIDEO_SAMPLE_SCALE
,
2366 LSMASH_CODEC_SPECIFIC_FORMAT_STRUCTURED
);
2369 isom_stsl_t
*stsl
= (isom_stsl_t
*)box
;
2370 lsmash_isom_sample_scale_t
*data
= (lsmash_isom_sample_scale_t
*)specific
->data
.structured
;
2371 data
->constraint_flag
= stsl
->constraint_flag
;
2372 data
->scale_method
= stsl
->scale_method
;
2373 data
->display_center_x
= stsl
->display_center_x
;
2374 data
->display_center_y
= stsl
->display_center_y
;
2376 else if( lsmash_check_box_type_identical( box
->type
, ISOM_BOX_TYPE_BTRT
) )
2378 specific
= lsmash_create_codec_specific_data( LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_VIDEO_H264_BITRATE
,
2379 LSMASH_CODEC_SPECIFIC_FORMAT_STRUCTURED
);
2382 isom_btrt_t
*btrt
= (isom_btrt_t
*)box
;
2383 lsmash_h264_bitrate_t
*data
= (lsmash_h264_bitrate_t
*)specific
->data
.structured
;
2384 data
->bufferSizeDB
= btrt
->bufferSizeDB
;
2385 data
->maxBitrate
= btrt
->maxBitrate
;
2386 data
->avgBitrate
= btrt
->avgBitrate
;
2388 else if( lsmash_check_box_type_identical( box
->type
, QT_BOX_TYPE_FIEL
) )
2390 specific
= lsmash_create_codec_specific_data( LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_VIDEO_FIELD_INFO
,
2391 LSMASH_CODEC_SPECIFIC_FORMAT_STRUCTURED
);
2394 isom_fiel_t
*fiel
= (isom_fiel_t
*)box
;
2395 lsmash_qt_field_info_t
*data
= (lsmash_qt_field_info_t
*)specific
->data
.structured
;
2396 data
->fields
= fiel
->fields
;
2397 data
->detail
= fiel
->detail
;
2399 else if( lsmash_check_box_type_identical( box
->type
, QT_BOX_TYPE_CSPC
) )
2401 specific
= lsmash_create_codec_specific_data( LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_VIDEO_PIXEL_FORMAT
,
2402 LSMASH_CODEC_SPECIFIC_FORMAT_STRUCTURED
);
2405 isom_cspc_t
*cspc
= (isom_cspc_t
*)box
;
2406 lsmash_qt_pixel_format_t
*data
= (lsmash_qt_pixel_format_t
*)specific
->data
.structured
;
2407 data
->pixel_format
= cspc
->pixel_format
;
2409 else if( lsmash_check_box_type_identical( box
->type
, QT_BOX_TYPE_SGBT
) )
2411 specific
= lsmash_create_codec_specific_data( LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_VIDEO_SIGNIFICANT_BITS
,
2412 LSMASH_CODEC_SPECIFIC_FORMAT_STRUCTURED
);
2415 isom_sgbt_t
*sgbt
= (isom_sgbt_t
*)box
;
2416 lsmash_qt_significant_bits_t
*data
= (lsmash_qt_significant_bits_t
*)specific
->data
.structured
;
2417 data
->significantBits
= sgbt
->significantBits
;
2419 else if( lsmash_check_box_type_identical( box
->type
, QT_BOX_TYPE_GLBL
) )
2421 specific
= lsmash_create_codec_specific_data( LSMASH_CODEC_SPECIFIC_DATA_TYPE_CODEC_GLOBAL_HEADER
,
2422 LSMASH_CODEC_SPECIFIC_FORMAT_STRUCTURED
);
2425 isom_glbl_t
*glbl
= (isom_glbl_t
*)box
;
2426 lsmash_codec_global_header_t
*data
= (lsmash_codec_global_header_t
*)specific
->data
.structured
;
2427 data
->header_size
= glbl
->header_size
;
2428 data
->header_data
= lsmash_memdup( glbl
->header_data
, glbl
->header_size
);
2429 if( !data
->header_data
)
2431 lsmash_destroy_codec_specific_data( specific
);
2437 if( lsmash_add_entry( &summary
->opaque
->list
, specific
) < 0 )
2439 lsmash_destroy_codec_specific_data( specific
);
2445 if( box
->size
< ISOM_BASEBOX_COMMON_SIZE
)
2447 uint8_t *data
= box
->binary
;
2448 lsmash_compact_box_type_t fourcc
= LSMASH_4CC( data
[4], data
[5], data
[6], data
[7] );
2449 lsmash_codec_specific_data_type type
= isom_get_codec_specific_data_type( fourcc
);
2450 lsmash_codec_specific_t
*specific
= lsmash_create_codec_specific_data( type
, LSMASH_CODEC_SPECIFIC_FORMAT_UNSTRUCTURED
);
2453 specific
->size
= box
->size
;
2454 specific
->data
.unstructured
= lsmash_memdup( box
->binary
, box
->size
);
2455 if( !specific
->data
.unstructured
2456 || lsmash_add_entry( &summary
->opaque
->list
, specific
) < 0 )
2458 lsmash_destroy_codec_specific_data( specific
);
2463 return (lsmash_summary_t
*)summary
;
2465 lsmash_cleanup_summary( (lsmash_summary_t
*)summary
);
2469 static int isom_append_structured_mp4sys_decoder_config( lsmash_codec_specific_list_t
*opaque
, isom_esds_t
*esds
)
2471 lsmash_bs_t
*bs
= lsmash_bs_create();
2473 return LSMASH_ERR_MEMORY_ALLOC
;
2474 /* Put box size, type, version and flags fields. */
2475 lsmash_bs_put_be32( bs
, 0 );
2476 lsmash_bs_put_be32( bs
, ISOM_BOX_TYPE_ESDS
.fourcc
);
2477 lsmash_bs_put_be32( bs
, 0 );
2478 /* Put ES Descriptor. */
2479 mp4sys_update_descriptor_size( esds
->ES
);
2480 mp4sys_write_descriptor( bs
, esds
->ES
);
2481 /* Export ES Descriptor Box as binary string. */
2483 uint8_t *esds_data
= lsmash_bs_export_data( bs
, &esds_size
);
2484 lsmash_bs_cleanup( bs
);
2486 return LSMASH_ERR_NAMELESS
;
2487 /* Update box size. */
2488 LSMASH_SET_BE32( esds_data
, esds_size
);
2489 lsmash_codec_specific_data_type type
= isom_get_codec_specific_data_type( ISOM_BOX_TYPE_ESDS
.fourcc
);
2490 lsmash_codec_specific_t
*specific
= lsmash_create_codec_specific_data( type
, LSMASH_CODEC_SPECIFIC_FORMAT_UNSTRUCTURED
);
2493 lsmash_free( esds_data
);
2494 return LSMASH_ERR_NAMELESS
;
2496 specific
->data
.unstructured
= esds_data
;
2497 specific
->size
= esds_size
;
2498 /* Convert unstructured CODEC specific data format into structured, and append it to the opaque list. */
2499 lsmash_codec_specific_t
*conv
= lsmash_convert_codec_specific_format( specific
, LSMASH_CODEC_SPECIFIC_FORMAT_STRUCTURED
);
2500 lsmash_destroy_codec_specific_data( specific
);
2502 return LSMASH_ERR_NAMELESS
;
2503 if( lsmash_add_entry( &opaque
->list
, conv
) < 0 )
2505 lsmash_destroy_codec_specific_data( conv
);
2506 return LSMASH_ERR_MEMORY_ALLOC
;
2511 lsmash_summary_t
*isom_create_audio_summary_from_description( isom_sample_entry_t
*sample_entry
)
2513 if( !sample_entry
|| !sample_entry
->file
|| !sample_entry
->parent
)
2515 isom_audio_entry_t
*audio
= (isom_audio_entry_t
*)sample_entry
;
2516 lsmash_audio_summary_t
*summary
= (lsmash_audio_summary_t
*)lsmash_create_summary( LSMASH_SUMMARY_TYPE_AUDIO
);
2519 summary
->sample_type
= audio
->type
;
2520 summary
->data_ref_index
= audio
->data_reference_index
;
2521 summary
->sample_size
= audio
->samplesize
;
2522 summary
->channels
= audio
->channelcount
;
2523 summary
->frequency
= audio
->samplerate
>> 16;
2524 if( ((isom_stsd_t
*)audio
->parent
)->version
== 0
2525 && audio
->file
->qt_compatible
2526 && isom_is_qt_audio( audio
->type
) )
2528 if( audio
->version
== 0 )
2529 isom_get_implicit_qt_fixed_comp_audio_sample_quants( audio
, &summary
->samples_in_frame
, &summary
->bytes_per_frame
, &summary
->sample_size
);
2530 else if( audio
->version
== 1 )
2532 summary
->channels
= audio
->bytesPerPacket
? audio
->bytesPerFrame
/ audio
->bytesPerPacket
: audio
->channelcount
;
2533 summary
->sample_size
= audio
->bytesPerPacket
* 8;
2534 summary
->samples_in_frame
= audio
->samplesPerPacket
;
2535 summary
->bytes_per_frame
= audio
->bytesPerFrame
;
2537 else if( audio
->version
== 2 )
2539 summary
->frequency
= (union {uint64_t i
; double d
;}){audio
->audioSampleRate
}.d
;
2540 summary
->channels
= audio
->numAudioChannels
;
2541 summary
->sample_size
= audio
->constBitsPerChannel
;
2542 summary
->samples_in_frame
= audio
->constLPCMFramesPerAudioPacket
;
2543 summary
->bytes_per_frame
= audio
->constBytesPerAudioPacket
;
2545 lsmash_codec_specific_t
*specific
= lsmash_create_codec_specific_data( LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_AUDIO_COMMON
,
2546 LSMASH_CODEC_SPECIFIC_FORMAT_STRUCTURED
);
2549 lsmash_qt_audio_common_t
*common
= (lsmash_qt_audio_common_t
*)specific
->data
.structured
;
2550 common
->revision_level
= audio
->revision_level
;
2551 common
->vendor
= audio
->vendor
;
2552 common
->compression_ID
= audio
->compression_ID
;
2553 if( lsmash_add_entry( &summary
->opaque
->list
, specific
) < 0 )
2555 lsmash_destroy_codec_specific_data( specific
);
2558 if( isom_is_lpcm_audio( audio
) )
2560 specific
= lsmash_create_codec_specific_data( LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_AUDIO_FORMAT_SPECIFIC_FLAGS
,
2561 LSMASH_CODEC_SPECIFIC_FORMAT_STRUCTURED
);
2564 lsmash_qt_audio_format_specific_flags_t
*data
= (lsmash_qt_audio_format_specific_flags_t
*)specific
->data
.structured
;
2565 if( audio
->version
== 2 )
2566 data
->format_flags
= audio
->formatSpecificFlags
;
2569 data
->format_flags
= 0;
2570 /* Here, don't override samplesize.
2571 * We should trust samplesize field in the description for misused CODEC indentifier. */
2572 lsmash_codec_type_t audio_type
= audio
->type
;
2573 if( lsmash_check_codec_type_identical( audio_type
, QT_CODEC_TYPE_FL32_AUDIO
)
2574 || lsmash_check_codec_type_identical( audio_type
, QT_CODEC_TYPE_FL64_AUDIO
) )
2575 data
->format_flags
= QT_LPCM_FORMAT_FLAG_FLOAT
;
2576 else if( lsmash_check_codec_type_identical( audio_type
, QT_CODEC_TYPE_TWOS_AUDIO
)
2577 || lsmash_check_codec_type_identical( audio_type
, QT_CODEC_TYPE_NONE_AUDIO
)
2578 || lsmash_check_codec_type_identical( audio_type
, QT_CODEC_TYPE_NOT_SPECIFIED
) )
2580 if( lsmash_check_codec_type_identical( audio_type
, QT_CODEC_TYPE_TWOS_AUDIO
) )
2581 data
->format_flags
= QT_LPCM_FORMAT_FLAG_BIG_ENDIAN
| QT_AUDIO_FORMAT_FLAG_SIGNED_INTEGER
;
2582 if( summary
->sample_size
> 8 )
2583 data
->format_flags
= QT_LPCM_FORMAT_FLAG_BIG_ENDIAN
;
2586 isom_wave_t
*wave
= (isom_wave_t
*)isom_get_extension_box_format( &audio
->extensions
, QT_BOX_TYPE_WAVE
);
2587 if( wave
&& wave
->enda
&& !wave
->enda
->littleEndian
)
2588 data
->format_flags
|= QT_LPCM_FORMAT_FLAG_BIG_ENDIAN
;
2589 if( lsmash_add_entry( &summary
->opaque
->list
, specific
) < 0 )
2591 lsmash_destroy_codec_specific_data( specific
);
2595 else if( audio
->version
== 2
2596 && (lsmash_check_codec_type_identical( audio
->type
, ISOM_CODEC_TYPE_ALAC_AUDIO
)
2597 || lsmash_check_codec_type_identical( audio
->type
, QT_CODEC_TYPE_ALAC_AUDIO
)) )
2598 switch( audio
->formatSpecificFlags
)
2600 case QT_ALAC_FORMAT_FLAG_16BIT_SOURCE_DATA
:
2601 summary
->sample_size
= 16;
2603 case QT_ALAC_FORMAT_FLAG_20BIT_SOURCE_DATA
:
2604 summary
->sample_size
= 20;
2606 case QT_ALAC_FORMAT_FLAG_24BIT_SOURCE_DATA
:
2607 summary
->sample_size
= 24;
2609 case QT_ALAC_FORMAT_FLAG_32BIT_SOURCE_DATA
:
2610 summary
->sample_size
= 32;
2616 else if( lsmash_check_codec_type_identical( audio
->type
, ISOM_CODEC_TYPE_SAMR_AUDIO
) )
2618 summary
->channels
= 1;
2619 summary
->frequency
= 8000;
2621 else if( lsmash_check_codec_type_identical( audio
->type
, ISOM_CODEC_TYPE_SAWB_AUDIO
) )
2623 summary
->channels
= 1;
2624 summary
->frequency
= 16000;
2626 uint32_t actual_sampling_rate
= 0;
2627 for( lsmash_entry_t
*entry
= audio
->extensions
.head
; entry
; entry
= entry
->next
)
2629 isom_box_t
*box
= (isom_box_t
*)entry
->data
;
2632 if( !(box
->manager
& LSMASH_BINARY_CODED_BOX
) )
2634 if( lsmash_check_box_type_identical( box
->type
, QT_BOX_TYPE_CHAN
) )
2636 lsmash_codec_specific_t
*specific
= lsmash_create_codec_specific_data( LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_AUDIO_CHANNEL_LAYOUT
,
2637 LSMASH_CODEC_SPECIFIC_FORMAT_STRUCTURED
);
2640 isom_chan_t
*chan
= (isom_chan_t
*)box
;
2641 lsmash_qt_audio_channel_layout_t
*data
= (lsmash_qt_audio_channel_layout_t
*)specific
->data
.structured
;
2642 data
->channelLayoutTag
= chan
->channelLayoutTag
;
2643 data
->channelBitmap
= chan
->channelBitmap
;
2644 if( lsmash_add_entry( &summary
->opaque
->list
, specific
) < 0 )
2646 lsmash_destroy_codec_specific_data( specific
);
2650 else if( lsmash_check_box_type_identical( box
->type
, ISOM_BOX_TYPE_ESDS
)
2651 || lsmash_check_box_type_identical( box
->type
, QT_BOX_TYPE_ESDS
) )
2653 isom_esds_t
*esds
= (isom_esds_t
*)box
;
2654 if( mp4sys_setup_summary_from_DecoderSpecificInfo( summary
, esds
->ES
) < 0
2655 || isom_append_structured_mp4sys_decoder_config( summary
->opaque
, esds
) < 0 )
2658 else if( lsmash_check_box_type_identical( box
->type
, ISOM_BOX_TYPE_SRAT
) )
2660 isom_srat_t
*srat
= (isom_srat_t
*)box
;
2661 actual_sampling_rate
= srat
->sampling_rate
;
2663 else if( lsmash_check_box_type_identical( box
->type
, QT_BOX_TYPE_WAVE
) )
2665 /* Don't append 'wave' extension itself to the opaque CODEC specific info list. */
2666 isom_wave_t
*wave
= (isom_wave_t
*)box
;
2667 lsmash_bs_t
*bs
= lsmash_bs_create();
2670 for( lsmash_entry_t
*wave_entry
= wave
->extensions
.head
; wave_entry
; wave_entry
= wave_entry
->next
)
2672 isom_box_t
*wave_ext
= (isom_box_t
*)wave_entry
->data
;
2675 lsmash_box_type_t box_type
= LSMASH_BOX_TYPE_INITIALIZER
;
2676 if( !(wave_ext
->manager
& LSMASH_BINARY_CODED_BOX
) )
2678 box_type
= wave_ext
->type
;
2679 if( lsmash_check_box_type_identical( box_type
, QT_BOX_TYPE_ENDA
) )
2681 isom_enda_t
*enda
= (isom_enda_t
*)wave_ext
;
2682 isom_bs_put_box_common( bs
, enda
);
2683 lsmash_bs_put_be16( bs
, enda
->littleEndian
);
2685 else if( lsmash_check_box_type_identical( box_type
, QT_BOX_TYPE_MP4A
) )
2687 isom_mp4a_t
*mp4a
= (isom_mp4a_t
*)wave_ext
;
2688 isom_bs_put_box_common( bs
, mp4a
);
2689 lsmash_bs_put_be32( bs
, mp4a
->unknown
);
2691 else if( lsmash_check_box_type_identical( box_type
, QT_BOX_TYPE_CHAN
) )
2693 isom_chan_t
*chan
= (isom_chan_t
*)wave_ext
;
2694 isom_bs_put_box_common( bs
, chan
);
2695 lsmash_bs_put_be32( bs
, chan
->channelLayoutTag
);
2696 lsmash_bs_put_be32( bs
, chan
->channelBitmap
);
2697 lsmash_bs_put_be32( bs
, chan
->numberChannelDescriptions
);
2698 if( chan
->channelDescriptions
)
2699 for( uint32_t i
= 0; i
< chan
->numberChannelDescriptions
; i
++ )
2701 isom_channel_description_t
*channelDescriptions
= (isom_channel_description_t
*)(&chan
->channelDescriptions
[i
]);
2702 if( !channelDescriptions
)
2704 lsmash_bs_cleanup( bs
);
2707 lsmash_bs_put_be32( bs
, channelDescriptions
->channelLabel
);
2708 lsmash_bs_put_be32( bs
, channelDescriptions
->channelFlags
);
2709 lsmash_bs_put_be32( bs
, channelDescriptions
->coordinates
[0] );
2710 lsmash_bs_put_be32( bs
, channelDescriptions
->coordinates
[1] );
2711 lsmash_bs_put_be32( bs
, channelDescriptions
->coordinates
[2] );
2714 else if( lsmash_check_box_type_identical( box_type
, QT_BOX_TYPE_ESDS
) )
2716 isom_esds_t
*esds
= (isom_esds_t
*)wave_ext
;
2718 || mp4sys_setup_summary_from_DecoderSpecificInfo( summary
, esds
->ES
) < 0
2719 || isom_append_structured_mp4sys_decoder_config( summary
->opaque
, esds
) < 0 )
2721 lsmash_bs_cleanup( bs
);
2727 /* Skip Format Box and Terminator Box since they are mandatory and fixed structure. */
2732 if( wave_ext
->size
< ISOM_BASEBOX_COMMON_SIZE
)
2734 uint8_t *data
= wave_ext
->binary
;
2735 box_type
.fourcc
= LSMASH_4CC( data
[4], data
[5], data
[6], data
[7] );
2736 lsmash_bs_put_bytes( bs
, wave_ext
->size
, wave_ext
->binary
);
2738 /* Export as binary string. */
2740 uint8_t *box_data
= lsmash_bs_export_data( bs
, &box_size
);
2741 lsmash_bs_empty( bs
);
2744 lsmash_bs_cleanup( bs
);
2747 /* Append as an unstructured CODEC specific info. */
2748 lsmash_codec_specific_data_type type
;
2749 if( box_type
.fourcc
== QT_BOX_TYPE_CHAN
.fourcc
)
2750 /* Complete audio channel layout is stored as binary string.
2751 * We distinguish it from one of the outside of 'wave' extension here. */
2752 type
= LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_AUDIO_DECOMPRESSION_PARAMETERS
;
2755 type
= isom_get_codec_specific_data_type( box_type
.fourcc
);
2756 if( type
== LSMASH_CODEC_SPECIFIC_DATA_TYPE_UNKNOWN
)
2757 type
= LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_AUDIO_DECOMPRESSION_PARAMETERS
;
2759 lsmash_codec_specific_t
*specific
= lsmash_create_codec_specific_data( type
, LSMASH_CODEC_SPECIFIC_FORMAT_UNSTRUCTURED
);
2762 lsmash_bs_cleanup( bs
);
2765 specific
->data
.unstructured
= box_data
;
2766 specific
->size
= box_size
;
2767 if( lsmash_add_entry( &summary
->opaque
->list
, specific
) < 0 )
2769 lsmash_destroy_codec_specific_data( specific
);
2770 lsmash_bs_cleanup( bs
);
2774 lsmash_bs_cleanup( bs
);
2779 if( box
->size
< ISOM_BASEBOX_COMMON_SIZE
)
2781 uint8_t *data
= box
->binary
;
2782 lsmash_compact_box_type_t fourcc
= LSMASH_4CC( data
[4], data
[5], data
[6], data
[7] );
2783 lsmash_codec_specific_data_type type
= isom_get_codec_specific_data_type( fourcc
);
2784 lsmash_codec_specific_t
*specific
= lsmash_create_codec_specific_data( type
, LSMASH_CODEC_SPECIFIC_FORMAT_UNSTRUCTURED
);
2787 specific
->size
= box
->size
;
2788 specific
->data
.unstructured
= lsmash_memdup( box
->binary
, box
->size
);
2789 if( !specific
->data
.unstructured
2790 || lsmash_add_entry( &summary
->opaque
->list
, specific
) < 0 )
2792 lsmash_destroy_codec_specific_data( specific
);
2795 if( specific
->type
== LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_AUDIO_DTS
2796 || specific
->type
== LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_AUDIO_AC_3
2797 || specific
->type
== LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_AUDIO_EC_3
)
2799 specific
= lsmash_convert_codec_specific_format( specific
, LSMASH_CODEC_SPECIFIC_FORMAT_STRUCTURED
);
2802 switch( specific
->type
)
2804 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_AUDIO_DTS
:
2806 lsmash_dts_specific_parameters_t
*param
= (lsmash_dts_specific_parameters_t
*)specific
->data
.structured
;
2807 summary
->sample_size
= param
->pcmSampleDepth
;
2808 summary
->samples_in_frame
= (summary
->frequency
* (512 << param
->FrameDuration
)) / param
->DTSSamplingFrequency
;
2811 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_AUDIO_AC_3
:
2813 lsmash_ac3_specific_parameters_t
*param
= (lsmash_ac3_specific_parameters_t
*)specific
->data
.structured
;
2814 summary
->frequency
= ac3_get_sample_rate( param
);
2815 summary
->channels
= ac3_get_channel_count( param
);
2816 summary
->samples_in_frame
= 1536;
2819 case LSMASH_CODEC_SPECIFIC_DATA_TYPE_ISOM_AUDIO_EC_3
:
2821 lsmash_eac3_specific_parameters_t
*param
= (lsmash_eac3_specific_parameters_t
*)specific
->data
.structured
;
2822 eac3_update_sample_rate( &summary
->frequency
, param
, NULL
);
2823 eac3_update_channel_count( &summary
->channels
, param
);
2824 summary
->samples_in_frame
= 1536;
2830 lsmash_destroy_codec_specific_data( specific
);
2834 /* Set the actual sampling rate. */
2835 if( actual_sampling_rate
)
2836 summary
->frequency
= actual_sampling_rate
;
2837 return (lsmash_summary_t
*)summary
;
2839 lsmash_cleanup_summary( (lsmash_summary_t
*)summary
);
2843 lsmash_codec_specific_t
*lsmash_get_codec_specific_data( lsmash_summary_t
*summary
, uint32_t extension_number
)
2845 if( !summary
|| !summary
->opaque
)
2848 for( lsmash_entry_t
*entry
= summary
->opaque
->list
.head
; entry
; entry
= entry
->next
)
2849 if( ++i
== extension_number
)
2850 return (lsmash_codec_specific_t
*)entry
->data
;
2854 uint32_t lsmash_count_codec_specific_data( lsmash_summary_t
*summary
)
2856 if( !summary
|| !summary
->opaque
)
2858 return summary
->opaque
->list
.entry_count
;
2861 int isom_compare_opaque_extensions( lsmash_summary_t
*a
, lsmash_summary_t
*b
)
2864 uint32_t in_number_of_extensions
= lsmash_count_codec_specific_data( a
);
2865 uint32_t out_number_of_extensions
= lsmash_count_codec_specific_data( b
);
2866 if( out_number_of_extensions
!= in_number_of_extensions
)
2868 uint32_t active_number_of_extensions
= in_number_of_extensions
;
2869 uint32_t identical_count
= 0;
2870 for( uint32_t j
= 1; j
<= in_number_of_extensions
; j
++ )
2872 lsmash_codec_specific_t
*in_cs_orig
= lsmash_get_codec_specific_data( a
, j
);
2873 lsmash_codec_specific_t
*in_cs
;
2874 lsmash_codec_specific_format compare_format
= LSMASH_CODEC_SPECIFIC_FORMAT_UNSTRUCTURED
;
2875 if( in_cs_orig
->format
== LSMASH_CODEC_SPECIFIC_FORMAT_STRUCTURED
)
2877 if( in_cs_orig
->type
== LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_VIDEO_COMMON
2878 || in_cs_orig
->type
== LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_AUDIO_COMMON
2879 || in_cs_orig
->type
== LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_AUDIO_FORMAT_SPECIFIC_FLAGS
)
2881 compare_format
= LSMASH_CODEC_SPECIFIC_FORMAT_STRUCTURED
;
2886 in_cs
= lsmash_convert_codec_specific_format( in_cs_orig
, LSMASH_CODEC_SPECIFIC_FORMAT_UNSTRUCTURED
);
2889 /* We don't support the format converter of this data type. */
2890 --active_number_of_extensions
;
2897 for( uint32_t k
= 1; k
<= out_number_of_extensions
; k
++ )
2899 lsmash_codec_specific_t
*out_cs_orig
= lsmash_get_codec_specific_data( b
, k
);
2900 if( out_cs_orig
->type
!= in_cs_orig
->type
)
2902 lsmash_codec_specific_t
*out_cs
;
2903 if( out_cs_orig
->format
== LSMASH_CODEC_SPECIFIC_FORMAT_STRUCTURED
)
2905 if( compare_format
== LSMASH_CODEC_SPECIFIC_FORMAT_STRUCTURED
)
2906 out_cs
= out_cs_orig
;
2909 out_cs
= lsmash_convert_codec_specific_format( out_cs_orig
, LSMASH_CODEC_SPECIFIC_FORMAT_UNSTRUCTURED
);
2915 out_cs
= out_cs_orig
;
2917 if( compare_format
== LSMASH_CODEC_SPECIFIC_FORMAT_UNSTRUCTURED
)
2918 identical
= out_cs
->size
== in_cs
->size
&& !memcmp( out_cs
->data
.unstructured
, in_cs
->data
.unstructured
, in_cs
->size
);
2921 if( in_cs
->type
== LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_VIDEO_COMMON
)
2923 lsmash_qt_video_common_t
*in_data
= (lsmash_qt_video_common_t
*)in_cs
->data
.structured
;
2924 lsmash_qt_video_common_t
*out_data
= (lsmash_qt_video_common_t
*)out_cs
->data
.structured
;
2925 identical
= in_data
->revision_level
== out_data
->revision_level
2926 && in_data
->vendor
== out_data
->vendor
2927 && in_data
->temporalQuality
== out_data
->temporalQuality
2928 && in_data
->spatialQuality
== out_data
->spatialQuality
2929 && in_data
->horizontal_resolution
== out_data
->horizontal_resolution
2930 && in_data
->vertical_resolution
== out_data
->vertical_resolution
2931 && in_data
->dataSize
== out_data
->dataSize
2932 && in_data
->frame_count
== out_data
->frame_count
2933 && in_data
->color_table_ID
== out_data
->color_table_ID
;
2935 else if( in_cs
->type
== LSMASH_CODEC_SPECIFIC_DATA_TYPE_QT_AUDIO_COMMON
)
2937 lsmash_qt_audio_common_t
*in_data
= (lsmash_qt_audio_common_t
*)in_cs
->data
.structured
;
2938 lsmash_qt_audio_common_t
*out_data
= (lsmash_qt_audio_common_t
*)out_cs
->data
.structured
;
2939 identical
= in_data
->revision_level
== out_data
->revision_level
2940 && in_data
->vendor
== out_data
->vendor
2941 && in_data
->compression_ID
== out_data
->compression_ID
;
2945 lsmash_qt_audio_format_specific_flags_t
*in_data
= (lsmash_qt_audio_format_specific_flags_t
*)in_cs
->data
.structured
;
2946 lsmash_qt_audio_format_specific_flags_t
*out_data
= (lsmash_qt_audio_format_specific_flags_t
*)out_cs
->data
.structured
;
2947 identical
= (in_data
->format_flags
== out_data
->format_flags
);
2950 if( out_cs
!= out_cs_orig
)
2951 lsmash_destroy_codec_specific_data( out_cs
);
2958 if( in_cs
!= in_cs_orig
)
2959 lsmash_destroy_codec_specific_data( in_cs
);
2961 return (identical_count
!= active_number_of_extensions
);
2964 int isom_get_implicit_qt_fixed_comp_audio_sample_quants
2966 isom_audio_entry_t
*audio
,
2967 uint32_t *samples_per_packet
,
2968 uint32_t *constant_bytes_per_frame
,
2969 uint32_t *sample_size
2972 if( lsmash_check_codec_type_identical( audio
->type
, QT_CODEC_TYPE_MAC3_AUDIO
) )
2974 *samples_per_packet
= 6;
2975 *constant_bytes_per_frame
= 2 * audio
->channelcount
;
2978 else if( lsmash_check_codec_type_identical( audio
->type
, QT_CODEC_TYPE_MAC6_AUDIO
) )
2980 *samples_per_packet
= 6;
2981 *constant_bytes_per_frame
= audio
->channelcount
;
2984 else if( lsmash_check_codec_type_identical( audio
->type
, QT_CODEC_TYPE_ADPCM17_AUDIO
) )
2986 *samples_per_packet
= 64;
2987 *constant_bytes_per_frame
= 34 * audio
->channelcount
;
2990 else if( lsmash_check_codec_type_identical( audio
->type
, QT_CODEC_TYPE_AGSM_AUDIO
) )
2992 *samples_per_packet
= 160;
2993 *constant_bytes_per_frame
= 33;
2996 else if( lsmash_check_codec_type_identical( audio
->type
, QT_CODEC_TYPE_ALAW_AUDIO
)
2997 || lsmash_check_codec_type_identical( audio
->type
, QT_CODEC_TYPE_ULAW_AUDIO
) )
2999 *samples_per_packet
= 1;
3000 *constant_bytes_per_frame
= audio
->channelcount
;