src/include/mm_camcorder.h

   1 /*
   2  * libmm-camcorder
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Jeongmo Yang <jm80.yang@samsung.com>
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  *
  20  */
  21
  22 /**
  23         @addtogroup CAMCORDER
  24         @{
  25
  26         @par
  27         This part describes the APIs with repect to Multimedia Camcorder.
  28         Camcorder is for recording audio and video from audio and video input devices, capturing
  29         still image from video input device, and audio recording from audio input
  30         device.
  31
  32         @par
  33         Camcorder can be reached by calling functions as shown in the following
  34         figure, "The State of Camcorder".
  35
  36         @par
  37         @image html     camcorder_state.png     "The State of Camcorder"        width=12cm
  38         @image latex    camcorder_state.png     "The State of Camcorder"        width=12cm
  39
  40         @par
  41         Between each states there is intermediate state, and in this state,
  42         any function call which change the camcorder state will be failed.
  43
  44         @par
  45         Recording state and paused state exists when the mode of camcorder is
  46         video-capture or audio-capture mode. In case of image-capture mode, CAPTURING state will
  47         exsit.
  48
  49         @par
  50 <div>
  51 <table>
  52         <tr>
  53                 <td>FUNCTION</td>
  54                 <td>PRE-STATE</td>
  55                 <td>POST-STATE</td>
  56                 <td>SYNC TYPE</td>
  57         </tr>
  58         <tr>
  59                 <td>mm_camcorder_create()</td>
  60                 <td>NONE</td>
  61                 <td>NULL</td>
  62                 <td>SYNC</td>
  63         </tr>
  64         <tr>
  65                 <td>mm_camcorder_destroy()</td>
  66                 <td>NULL</td>
  67                 <td>NONE</td>
  68                 <td>SYNC</td>
  69         </tr>
  70         <tr>
  71                 <td>mm_camcorder_realize()</td>
  72                 <td>NULL</td>
  73                 <td>READY</td>
  74                 <td>SYNC</td>
  75         </tr>
  76         <tr>
  77                 <td>mm_camcorder_unrealize()</td>
  78                 <td>READY</td>
  79                 <td>NULL</td>
  80                 <td>SYNC</td>
  81         </tr>
  82         <tr>
  83                 <td>mm_camcorder_start()</td>
  84                 <td>READY</td>
  85                 <td>PREPARED</td>
  86                 <td>SYNC</td>
  87         </tr>
  88         <tr>
  89                 <td>mm_camcorder_stop()</td>
  90                 <td>PREPARED</td>
  91                 <td>READY</td>
  92                 <td>SYNC</td>
  93         </tr>
  94         <tr>
  95                 <td>mm_camcorder_capture_start()</td>
  96                 <td>PREPARED</td>
  97                 <td>CAPTURING</td>
  98                 <td>SYNC</td>
  99         </tr>
 100         <tr>
 101                 <td>mm_camcorder_capture_stop()</td>
 102                 <td>CAPTURING</td>
 103                 <td>PREPARED</td>
 104                 <td>SYNC</td>
 105         </tr>
 106         <tr>
 107                 <td>mm_camcorder_record()</td>
 108                 <td>PREPARED/PAUSED</td>
 109                 <td>RECORDING</td>
 110                 <td>SYNC</td>
 111         </tr>
 112         <tr>
 113                 <td>mm_camcorder_pause()</td>
 114                 <td>RECORDING</td>
 115                 <td>PAUSED</td>
 116                 <td>SYNC</td>
 117         </tr>
 118         <tr>
 119                 <td>mm_camcorder_commit()</td>
 120                 <td>RECORDING/PAUSED</td>
 121                 <td>PREPARED</td>
 122                 <td>SYNC</td>
 123         </tr>
 124         <tr>
 125                 <td>mm_camcorder_cancel()</td>
 126                 <td>RECORDING/PAUSED</td>
 127                 <td>PREPARED</td>
 128                 <td>SYNC</td>
 129         </tr>
 130         <tr>
 131                 <td>mm_camcorder_set_message_callback()</td>
 132                 <td>N/A</td>
 133                 <td>N/A</td>
 134                 <td>SYNC</td>
 135         </tr>
 136         <tr>
 137                 <td>mm_camcorder_set_video_stream_callback()</td>
 138                 <td>N/A</td>
 139                 <td>N/A</td>
 140                 <td>SYNC</td>
 141         </tr>
 142         <tr>
 143                 <td>mm_camcorder_set_video_capture_callback()</td>
 144                 <td>N/A</td>
 145                 <td>N/A</td>
 146                 <td>SYNC</td>
 147         </tr>
 148         <tr>
 149                 <td>mm_camcorder_get_state()</td>
 150                 <td>N/A</td>
 151                 <td>N/A</td>
 152                 <td>SYNC</td>
 153         </tr>
 154         <tr>
 155                 <td>mm_camcorder_get_attributes()</td>
 156                 <td>N/A</td>
 157                 <td>N/A</td>
 158                 <td>SYNC</td>
 159         </tr>
 160         <tr>
 161                 <td>mm_camcorder_set_attributes()</td>
 162                 <td>N/A</td>
 163                 <td>N/A</td>
 164                 <td>SYNC</td>
 165         </tr>
 166         <tr>
 167                 <td>mm_camcorder_get_attribute_info()</td>
 168                 <td>N/A</td>
 169                 <td>N/A</td>
 170                 <td>SYNC</td>
 171         </tr>
 172         <tr>
 173                 <td>mm_camcorder_init_focusing()</td>
 174                 <td>N/A</td>
 175                 <td>N/A</td>
 176                 <td>SYNC</td>
 177         </tr>
 178         <tr>
 179                 <td>mm_camcorder_start_focusing()</td>
 180                 <td>N/A</td>
 181                 <td>N/A</td>
 182                 <td>SYNC</td>
 183         </tr>
 184         <tr>
 185                 <td>mm_camcorder_stop_focusing()</td>
 186                 <td>N/A</td>
 187                 <td>N/A</td>
 188                 <td>SYNC</td>
 189         </tr>
 190 </table>
 191 </div>
 192
 193         @par
 194         * Attribute @n
 195         Attribute system is an interface to operate camcorder. Depending on each attribute, camcorder behaves differently.
 196         Attribute system provides get/set functions. Setting proper attributes, a user can control camcorder as he want. (mm_camcorder_set_attributes())
 197         Also, a user can comprehend current status of the camcorder, calling getter function(mm_camcorder_get_attributes()).
 198         Beware, arguments of mm_camcorder_set_attributes() and mm_camcorder_get_attributes() should be finished with 'NULL'.
 199         This is a rule for the variable argument.
 200         @par
 201         Besides its value, each Attribute also has 'type' and 'validity type'. 'type' describes variable type that the attribute can get.
 202         If you input a value that has wrong type, camcorder will not work properly or be crashed. 'validity' describes array or
 203         range of values that are able to set to the attribute. 'validity type' defines type of the 'validity'.
 204         @par
 205         A user can retrieve these values using mm_camcorder_get_attribute_info().
 206         Following tables have 'Attribute name', 'Attribute macro', 'Type', and 'Validity type'. You can refer '#MMCamAttrsType' and '#MMCamAttrsValidType'
 207         for discerning 'Type' and 'Validity type'.
 208
 209
 210         @par
 211         Following are the attributes which should be set before initialization (#mm_camcorder_realize):
 212
 213         @par
 214 <div>
 215 <table>
 216         <tr>
 217                 <td><center><b>Attribute</b></center></td>
 218                 <td><center><b>Description</b></center></td>
 219         </tr>
 220         <tr>
 221                 <td>#MMCAM_MODE</td>
 222                 <td>Mode of camcorder ( still/video/audio )</td>
 223         </tr>
 224         <tr>
 225                 <td>#MMCAM_AUDIO_DEVICE</td>
 226                 <td>Audio device ID for capturing audio stream</td>
 227         </tr>
 228         <tr>
 229                 <td>#MMCAM_CAMERA_DEVICE</td>
 230                 <td>Video device ID for capturing video stream</td>
 231         </tr>
 232         <tr>
 233                 <td>#MMCAM_AUDIO_ENCODER</td>
 234                 <td>Audio codec for encoding audio stream</td>
 235         </tr>
 236         <tr>
 237                 <td>#MMCAM_VIDEO_ENCODER</td>
 238                 <td>Video codec for encoding video stream</td>
 239         </tr>
 240         <tr>
 241                 <td>#MMCAM_IMAGE_ENCODER</td>
 242                 <td>Image codec for capturing still-image</td>
 243         </tr>
 244         <tr>
 245                 <td>#MMCAM_FILE_FORMAT</td>
 246                 <td>File format for recording media stream</td>
 247         </tr>
 248         <tr>
 249                 <td>#MMCAM_AUDIO_SAMPLERATE</td>
 250                 <td>Sampling rate of audio stream ( This is an integer field )</td>
 251         </tr>
 252         <tr>
 253                 <td>#MMCAM_AUDIO_FORMAT</td>
 254                 <td>Audio format of each sample</td>
 255         </tr>
 256         <tr>
 257                 <td>#MMCAM_AUDIO_CHANNEL</td>
 258                 <td>Channels of each sample ( This is an integer field )</td>
 259         </tr>
 260         <tr>
 261                 <td>#MMCAM_AUDIO_INPUT_ROUTE(deprecated)</td>
 262                 <td>Set audio input route</td>
 263         </tr>
 264         <tr>
 265                 <td>#MMCAM_CAMERA_FORMAT</td>
 266                 <td>Format of video stream. This is an integer field</td>
 267         </tr>
 268         <tr>
 269                 <td>#MMCAM_CAMERA_FPS</td>
 270                 <td>Frames per second ( This is an integer field )</td>
 271         </tr>
 272         <tr>
 273                 <td>#MMCAM_CAMERA_WIDTH</td>
 274                 <td>Width of input video stream</td>
 275         </tr>
 276         <tr>
 277                 <td>#MMCAM_CAMERA_HEIGHT</td>
 278                 <td>Height of input video stream</td>
 279         </tr>
 280         <tr>
 281                 <td>#MMCAM_CAMERA_FPS_AUTO</td>
 282                 <td>FPS Auto. When you set true to this attribute, FPS will vary depending on the amount of the light.</td>
 283         </tr>
 284         <tr>
 285                 <td>#MMCAM_DISPLAY_HANDLE</td>
 286                 <td>Pointer of display buffer or ID of xwindow</td>
 287         </tr>
 288         <tr>
 289                 <td>#MMCAM_DISPLAY_DEVICE</td>
 290                 <td>Device of display</td>
 291         </tr>
 292         <tr>
 293                 <td>#MMCAM_DISPLAY_SURFACE</td>
 294                 <td>Surface of display</td>
 295         </tr>
 296         <tr>
 297                 <td>#MMCAM_DISPLAY_SOURCE_X</td>
 298                 <td>X position of source rectangle. When you want to crop the source, you can set the area with this value.</td>
 299         </tr>
 300         <tr>
 301                 <td>#MMCAM_DISPLAY_SOURCE_Y</td>
 302                 <td>Y position of source rectangle. When you want to crop the source, you can set the area with this value.</td>
 303         </tr>
 304         <tr>
 305                 <td>#MMCAM_DISPLAY_SOURCE_WIDTH</td>
 306                 <td>Width of source rectangle. When you want to crop the source, you can set the area with this value.</td>
 307         </tr>
 308         <tr>
 309                 <td>#MMCAM_DISPLAY_SOURCE_HEIGHT</td>
 310                 <td>Height of source rectangle. When you want to crop the source, you can set the area with this value.</td>
 311         </tr>
 312         <tr>
 313                 <td>#MMCAM_DISPLAY_ROTATION</td>
 314                 <td>Rotation of display</td>
 315         </tr>
 316         <tr>
 317                 <td>#MMCAM_DISPLAY_VISIBLE</td>
 318                 <td>Visible of display</td>
 319         </tr>
 320         <tr>
 321                 <td>#MMCAM_DISPLAY_SCALE</td>
 322                 <td>A scale of displayed image</td>
 323         </tr>
 324         <tr>
 325                 <td>#MMCAM_DISPLAY_GEOMETRY_METHOD</td>
 326                 <td>A method that describes a form of geometry for display</td>
 327         </tr>
 328 </table>
 329 </div>
 330
 331         @par
 332         Following are the attributes which should be set before recording (mm_camcorder_record()):
 333
 334         @par
 335 <div>
 336 <table>
 337         <tr>
 338                 <td><center><b>Attribute</b></center></td>
 339                 <td><center><b>Description</b></center></td>
 340         </tr>
 341         <tr>
 342                 <td>#MMCAM_AUDIO_ENCODER_BITRATE</td>
 343                 <td>Bitrate of Audio Encoder</td>
 344         </tr>
 345         <tr>
 346                 <td>#MMCAM_VIDEO_ENCODER_BITRATE</td>
 347                 <td>Bitrate of Video Encoder</td>
 348         </tr>
 349         <tr>
 350                 <td>#MMCAM_TARGET_FILENAME</td>
 351                 <td>Target filename. Only used in Audio/Video recording. This is not used for capturing.</td>
 352         </tr>
 353         <tr>
 354                 <td>#MMCAM_TARGET_TIME_LIMIT</td>
 355                 <td>Time limit of recording file. If the elapsed time of recording reaches this value.</td>
 356         </tr>
 357 </table>
 358 </div>
 359
 360         @par
 361         Following are the attributes which should be set before capturing (mm_camcorder_capture_start()):
 362
 363         @par
 364 <div>
 365 <table>
 366         <tr>
 367                 <td><center><b>Attribute</b></center></td>
 368                 <td><center><b>Description</b></center></td>
 369         </tr>
 370         <tr>
 371                 <td>#MMCAM_IMAGE_ENCODER_QUALITY</td>
 372                 <td>Encoding quality of Image codec</td>
 373         </tr>
 374         <tr>
 375                 <td>#MMCAM_CAPTURE_FORMAT</td>
 376                 <td>Pixel format that you want to capture</td>
 377         </tr>
 378         <tr>
 379                 <td>#MMCAM_CAPTURE_WIDTH</td>
 380                 <td>Width of the image that you want to capture</td>
 381         </tr>
 382         <tr>
 383                 <td>#MMCAM_CAPTURE_HEIGHT</td>
 384                 <td>Height of the image that you want to capture</td>
 385         </tr>
 386         <tr>
 387                 <td>#MMCAM_CAPTURE_COUNT</td>
 388                 <td>Total count of capturing</td>
 389         </tr>
 390         <tr>
 391                 <td>#MMCAM_CAPTURE_INTERVAL</td>
 392                 <td>Interval between each capturing on Multishot ( MMCAM_CAPTURE_COUNT > 1 )</td>
 393         </tr>
 394 </table>
 395 </div>
 396
 397         @par
 398         Following are the attributes which can be set anytime:
 399
 400         @par
 401 <div>
 402 <table>
 403         <tr>
 404                 <td><center><b>Attribute</b></center></td>
 405                 <td><center><b>Description</b></center></td>
 406         </tr>
 407         <tr>
 408                 <td>#MMCAM_AUDIO_VOLUME</td>
 409                 <td>Input volume of audio source ( double value )</td>
 410         </tr>
 411         <tr>
 412                 <td>#MMCAM_CAMERA_DIGITAL_ZOOM</td>
 413                 <td>Digital zoom level</td>
 414         </tr>
 415         <tr>
 416                 <td>#MMCAM_CAMERA_OPTICAL_ZOOM</td>
 417                 <td>Optical zoom level</td>
 418         </tr>
 419         <tr>
 420                 <td>#MMCAM_CAMERA_FOCUS_MODE</td>
 421                 <td>Focus mode</td>
 422         </tr>
 423         <tr>
 424                 <td>#MMCAM_CAMERA_AF_SCAN_RANGE</td>
 425                 <td>AF Scan range</td>
 426         </tr>
 427         <tr>
 428                 <td>#MMCAM_CAMERA_AF_TOUCH_X</td>
 429                 <td>X coordinate of touching position</td>
 430         </tr>
 431         <tr>
 432                 <td>#MMCAM_CAMERA_AF_TOUCH_Y</td>
 433                 <td>Y coordinate of touching position</td>
 434         </tr>
 435         <tr>
 436                 <td>#MMCAM_CAMERA_AF_TOUCH_WIDTH</td>
 437                 <td>Width of touching area</td>
 438         </tr>
 439         <tr>
 440                 <td>#MMCAM_CAMERA_AF_TOUCH_HEIGHT</td>
 441                 <td>Height of touching area</td>
 442         </tr>
 443         <tr>
 444                 <td>#MMCAM_CAMERA_EXPOSURE_MODE</td>
 445                 <td>Exposure mode</td>
 446         </tr>
 447         <tr>
 448                 <td>#MMCAM_CAMERA_EXPOSURE_VALUE</td>
 449                 <td>Exposure value</td>
 450         </tr>
 451         <tr>
 452                 <td>#MMCAM_CAMERA_F_NUMBER</td>
 453                 <td>f number of camera</td>
 454         </tr>
 455         <tr>
 456                 <td>#MMCAM_CAMERA_SHUTTER_SPEED</td>
 457                 <td>Shutter speed</td>
 458         </tr>
 459         <tr>
 460                 <td>#MMCAM_CAMERA_ISO</td>
 461                 <td>ISO of capturing image</td>
 462         </tr>
 463         <tr>
 464                 <td>#MMCAM_CAMERA_WDR</td>
 465                 <td>Wide dynamic range</td>
 466         </tr>
 467         <tr>
 468                 <td>#MMCAM_CAMERA_ANTI_HANDSHAKE</td>
 469                 <td>Anti Handshake</td>
 470         </tr>
 471         <tr>
 472                 <td>#MMCAM_CAMERA_FOCAL_LENGTH</td>
 473                 <td>Focal length of camera lens</td>
 474         </tr>
 475         <tr>
 476                 <td>#MMCAM_FILTER_BRIGHTNESS</td>
 477                 <td>Brightness level</td>
 478         </tr>
 479         <tr>
 480                 <td>#MMCAM_FILTER_CONTRAST</td>
 481                 <td>Contrast level</td>
 482         </tr>
 483         <tr>
 484                 <td>#MMCAM_FILTER_WB</td>
 485                 <td>White balance</td>
 486         </tr>
 487         <tr>
 488                 <td>#MMCAM_FILTER_COLOR_TONE</td>
 489                 <td>Color tone (Color effect)</td>
 490         </tr>
 491         <tr>
 492                 <td>#MMCAM_FILTER_SCENE_MODE</td>
 493                 <td>Scene mode (Program mode)</td>
 494         </tr>
 495         <tr>
 496                 <td>#MMCAM_FILTER_SATURATION</td>
 497                 <td>Saturation level</td>
 498         </tr>
 499         <tr>
 500                 <td>#MMCAM_FILTER_HUE</td>
 501                 <td>Hue level</td>
 502         </tr>
 503         <tr>
 504                 <td>#MMCAM_FILTER_SHARPNESS</td>
 505                 <td>Sharpness level</td>
 506         </tr>
 507         <tr>
 508                 <td>#MMCAM_CAPTURE_BREAK_CONTINUOUS_SHOT</td>
 509                 <td>Set this as true when you want to stop multishot immediately</td>
 510         </tr>
 511         <tr>
 512                 <td>#MMCAM_DISPLAY_RECT_X</td>
 513                 <td>X position of display rectangle (This is only available when MMCAM_DISPLAY_GEOMETRY_METHOD is MM_CAMCORDER_CUSTOM_ROI)</td>
 514         </tr>
 515         <tr>
 516                 <td>#MMCAM_DISPLAY_RECT_Y</td>
 517                 <td>Y position of display rectangle (This is only available when MMCAM_DISPLAY_GEOMETRY_METHOD is MM_CAMCORDER_CUSTOM_ROI)</td>
 518         </tr>
 519         <tr>
 520                 <td>#MMCAM_DISPLAY_RECT_WIDTH</td>
 521                 <td>Width of display rectangle (This is only available when MMCAM_DISPLAY_GEOMETRY_METHOD is MM_CAMCORDER_CUSTOM_ROI)</td>
 522         </tr>
 523         <tr>
 524                 <td>#MMCAM_DISPLAY_RECT_HEIGHT</td>
 525                 <td>Height of display rectangle (This is only available when MMCAM_DISPLAY_GEOMETRY_METHOD is MM_CAMCORDER_CUSTOM_ROI)</td>
 526         </tr>
 527         <tr>
 528                 <td>#MMCAM_TAG_ENABLE</td>
 529                 <td>Enable to write tags (If this value is FALSE, none of tag information will be written to captured file)</td>
 530         </tr>
 531         <tr>
 532                 <td>#MMCAM_TAG_IMAGE_DESCRIPTION</td>
 533                 <td>Image description</td>
 534         </tr>
 535         <tr>
 536                 <td>#MMCAM_TAG_ORIENTATION</td>
 537                 <td>Orientation of captured image</td>
 538         </tr>
 539         <tr>
 540                 <td>#MMCAM_TAG_SOFTWARE</td>
 541                 <td>software name and version</td>
 542         </tr>
 543         <tr>
 544                 <td>#MMCAM_TAG_LATITUDE</td>
 545                 <td>Latitude of captured postion (GPS information)</td>
 546         </tr>
 547         <tr>
 548                 <td>#MMCAM_TAG_LONGITUDE</td>
 549                 <td>Longitude of captured postion (GPS information)</td>
 550         </tr>
 551         <tr>
 552                 <td>#MMCAM_TAG_ALTITUDE</td>
 553                 <td>Altitude of captured postion (GPS information)</td>
 554         </tr>
 555         <tr>
 556                 <td>#MMCAM_STROBE_CONTROL</td>
 557                 <td>Strobe control</td>
 558         </tr>
 559         <tr>
 560                 <td>#MMCAM_STROBE_MODE</td>
 561                 <td>Operation Mode of strobe</td>
 562         </tr>
 563         <tr>
 564                 <td>#MMCAM_DETECT_MODE</td>
 565                 <td>Detection mode</td>
 566         </tr>
 567         <tr>
 568                 <td>#MMCAM_DETECT_NUMBER</td>
 569                 <td>Total number of detected object</td>
 570         </tr>
 571         <tr>
 572                 <td>#MMCAM_DETECT_FOCUS_SELECT</td>
 573                 <td>Select one of detected objects</td>
 574         </tr>
 575 </table>
 576 </div>
 577  */
 578
 579
 580
 581 #ifndef __MM_CAMCORDER_H__
 582 #define __MM_CAMCORDER_H__
 583
 584
 585 /*=======================================================================================
 586 | INCLUDE FILES                                                                         |
 587 ========================================================================================*/
 588 #include <glib.h>
 589
 590 #include <mm_types.h>
 591 #include <mm_error.h>
 592 #include <mm_message.h>
 593
 594 #ifdef __cplusplus
 595 extern "C" {
 596 #endif
 597
 598 /*=======================================================================================
 599 | GLOBAL DEFINITIONS AND DECLARATIONS FOR CAMCORDER                                     |
 600 ========================================================================================*/
 601
 602 /*=======================================================================================
 603 | MACRO DEFINITIONS                                                                     |
 604 ========================================================================================*/
 605 /**
 606  * Get numerator. Definition for fraction setting, such as MMCAM_CAMERA_SHUTTER_SPEED and MMCAM_CAMERA_EXPOSURE_VALUE.
 607  */
 608 #define MM_CAMCORDER_GET_NUMERATOR(x)                                   ((int)(((int)(x) >> 16) & 0xFFFF))
 609 /**
 610  * Get denominator. Definition for fraction setting, such as MMCAM_CAMERA_SHUTTER_SPEED and MMCAM_CAMERA_EXPOSURE_VALUE.
 611  */
 612 #define MM_CAMCORDER_GET_DENOMINATOR(x)                                 ((int)(((int)(x)) & 0xFFFF))
 613 /**
 614  * Set fraction value. Definition for fraction setting, such as MMCAM_CAMERA_SHUTTER_SPEED and MMCAM_CAMERA_EXPOSURE_VALUE.
 615  */
 616 #define MM_CAMCORDER_SET_FRACTION(numerator,denominator)        ((int)((((int)(numerator)) << 16) | (int)(denominator)))
 617
 618 /* Attributes Macros */
 619 /**
 620  * Mode of camcorder (still/video/audio).
 621  * @see         MMCamcorderModeType
 622  */
 623 #define MMCAM_MODE                              "mode"
 624
 625 /**
 626  * Audio device ID for capturing audio stream.
 627  * @see         MMAudioDeviceType (in mm_types.h)
 628  */
 629 #define MMCAM_AUDIO_DEVICE                      "audio-device"
 630
 631 /**
 632  * Video device ID for capturing video stream.
 633  * @see         MMVideoDeviceType (in mm_types.h)
 634  */
 635 #define MMCAM_CAMERA_DEVICE                     "camera-device"
 636
 637 /**
 638  * Audio codec for encoding audio stream.
 639  * @see         MMAudioCodecType  (in mm_types.h)
 640  */
 641 #define MMCAM_AUDIO_ENCODER                     "audio-encoder"
 642
 643 /**
 644  * Video codec for encoding video stream.
 645  * @see         MMVideoCodecType (in mm_types.h)
 646  */
 647 #define MMCAM_VIDEO_ENCODER                     "video-encoder"
 648
 649 /**
 650  * Image codec for capturing still-image.
 651  * @see         MMImageCodecType (in mm_types.h)
 652  */
 653 #define MMCAM_IMAGE_ENCODER                     "image-encoder"
 654
 655 /**
 656  * File format for recording media stream.
 657  * @see         MMFileFormatType (in mm_types.h)
 658  */
 659 #define MMCAM_FILE_FORMAT                       "file-format"
 660
 661 /**
 662  * Sampling rate of audio stream. This is an integer field.
 663  */
 664 #define MMCAM_AUDIO_SAMPLERATE                  "audio-samplerate"
 665
 666 /**
 667  * Audio format of each sample.
 668  * @see         MMCamcorderAudioFormat
 669  */
 670 #define MMCAM_AUDIO_FORMAT                      "audio-format"
 671
 672 /**
 673  * Channels of each sample. This is an integer field.
 674  */
 675 #define MMCAM_AUDIO_CHANNEL                     "audio-channel"
 676
 677 /**
 678  * Input volume of audio source. Double value.
 679  */
 680 #define MMCAM_AUDIO_VOLUME                      "audio-volume"
 681
 682 /**
 683  * Set audio input route
 684  * @remarks     Deprecated. This will be removed soon.
 685  * @see         MMAudioRoutePolicy (in mm_types.h)
 686  */
 687 #define MMCAM_AUDIO_INPUT_ROUTE                 "audio-input-route"
 688
 689 /**
 690  * Format of video stream. This is an integer field
 691  * @see         MMPixelFormatType (in mm_types.h)
 692  */
 693 #define MMCAM_CAMERA_FORMAT                     "camera-format"
 694
 695 /**
 696  * Frames per second. This is an integer field
 697  *
 698  */
 699 #define MMCAM_CAMERA_FPS                        "camera-fps"
 700
 701 /**
 702  * Width of input video stream.
 703  */
 704 #define MMCAM_CAMERA_WIDTH                      "camera-width"
 705
 706 /**
 707  * Height of input video stream.
 708  * @see
 709  */
 710 #define MMCAM_CAMERA_HEIGHT                     "camera-height"
 711
 712 /**
 713  * Digital zoom level.
 714  */
 715 #define MMCAM_CAMERA_DIGITAL_ZOOM               "camera-digital-zoom"
 716
 717 /**
 718  * Optical zoom level.
 719  */
 720 #define MMCAM_CAMERA_OPTICAL_ZOOM               "camera-optical-zoom"
 721
 722 /**
 723  * Focus mode
 724  * @see         MMCamcorderFocusMode
 725  */
 726 #define MMCAM_CAMERA_FOCUS_MODE                 "camera-focus-mode"
 727
 728 /**
 729  * AF Scan range
 730  * @see         MMCamcorderAutoFocusType
 731  */
 732 #define MMCAM_CAMERA_AF_SCAN_RANGE              "camera-af-scan-range"
 733
 734 /**
 735  * X coordinate of touching position. Only available when you set '#MM_CAMCORDER_AUTO_FOCUS_TOUCH' to '#MMCAM_CAMERA_AF_SCAN_RANGE'.
 736  * @see         MMCamcorderAutoFocusType
 737  */
 738 #define MMCAM_CAMERA_AF_TOUCH_X                 "camera-af-touch-x"
 739
 740 /**
 741  * Y coordinate of touching position. Only available when you set '#MM_CAMCORDER_AUTO_FOCUS_TOUCH' to '#MMCAM_CAMERA_AF_SCAN_RANGE'.
 742  * @see         MMCamcorderAutoFocusType
 743  */
 744 #define MMCAM_CAMERA_AF_TOUCH_Y                 "camera-af-touch-y"
 745
 746 /**
 747  * Width of touching area. Only available when you set '#MM_CAMCORDER_AUTO_FOCUS_TOUCH' to '#MMCAM_CAMERA_AF_SCAN_RANGE'.
 748  * @see         MMCamcorderAutoFocusType
 749  */
 750 #define MMCAM_CAMERA_AF_TOUCH_WIDTH             "camera-af-touch-width"
 751
 752 /**
 753  * Height of touching area. Only available when you set '#MM_CAMCORDER_AUTO_FOCUS_TOUCH' to '#MMCAM_CAMERA_AF_SCAN_RANGE'.
 754  * @see         MMCamcorderAutoFocusType
 755  */
 756 #define MMCAM_CAMERA_AF_TOUCH_HEIGHT            "camera-af-touch-height"
 757
 758 /**
 759  * Exposure mode
 760  * @see         MMCamcorderAutoExposureType
 761  */
 762 #define MMCAM_CAMERA_EXPOSURE_MODE              "camera-exposure-mode"
 763
 764 /**
 765  * Exposure value
 766  */
 767 #define MMCAM_CAMERA_EXPOSURE_VALUE             "camera-exposure-value"
 768
 769 /**
 770  * f number of camera
 771  */
 772 #define MMCAM_CAMERA_F_NUMBER                   "camera-f-number"
 773
 774 /**
 775  * Shutter speed
 776  */
 777 #define MMCAM_CAMERA_SHUTTER_SPEED              "camera-shutter-speed"
 778
 779 /**
 780  * ISO of capturing image
 781  * @see         MMCamcorderISOType
 782  */
 783 #define MMCAM_CAMERA_ISO                        "camera-iso"
 784
 785 /**
 786  * Wide dynamic range.
 787  * @see         MMCamcorderWDRMode
 788  */
 789 #define MMCAM_CAMERA_WDR                        "camera-wdr"
 790
 791 /**
 792  * Focal length of camera lens.
 793  */
 794 #define MMCAM_CAMERA_FOCAL_LENGTH               "camera-focal-length"
 795
 796 /**
 797  * Anti Handshake
 798  * @see         MMCamcorderAHSMode
 799  */
 800 #define MMCAM_CAMERA_ANTI_HANDSHAKE             "camera-anti-handshake"
 801
 802 /**
 803  * FPS Auto. When you set true to this attribute, FPS will vary depending on the amount of the light.
 804  */
 805 #define MMCAM_CAMERA_FPS_AUTO                   "camera-fps-auto"
 806
 807 /**
 808  * Rotation angle of video input stream.
 809  * @see         MMVideoInputRotationType (in mm_types.h)
 810  */
 811 #define MMCAM_CAMERA_ROTATION                   "camera-rotation"
 812
 813 /**
 814  * Bitrate of Audio Encoder
 815  */
 816 #define MMCAM_AUDIO_ENCODER_BITRATE             "audio-encoder-bitrate"
 817
 818 /**
 819  * Bitrate of Video Encoder
 820  */
 821 #define MMCAM_VIDEO_ENCODER_BITRATE             "video-encoder-bitrate"
 822
 823 /**
 824  * Encoding quality of Image codec
 825  */
 826 #define MMCAM_IMAGE_ENCODER_QUALITY             "image-encoder-quality"
 827
 828 /**
 829  * Brightness level
 830  */
 831 #define MMCAM_FILTER_BRIGHTNESS                 "filter-brightness"
 832
 833 /**
 834  * Contrast level
 835  */
 836 #define MMCAM_FILTER_CONTRAST                   "filter-contrast"
 837
 838 /**
 839  * White balance
 840  * @see         MMCamcorderWhiteBalanceType
 841  */
 842 #define MMCAM_FILTER_WB                         "filter-wb"
 843
 844 /**
 845  * Color tone. (Color effect)
 846  * @see         MMCamcorderColorToneType
 847  */
 848 #define MMCAM_FILTER_COLOR_TONE                 "filter-color-tone"
 849
 850 /**
 851  * Scene mode (Program mode)
 852  * @see         MMCamcorderSceneModeType
 853  */
 854 #define MMCAM_FILTER_SCENE_MODE                 "filter-scene-mode"
 855
 856 /**
 857  * Saturation  level
 858  */
 859 #define MMCAM_FILTER_SATURATION                 "filter-saturation"
 860
 861 /**
 862  * Hue  level
 863  */
 864 #define MMCAM_FILTER_HUE                        "filter-hue"
 865
 866 /**
 867  * Sharpness  level
 868  */
 869 #define MMCAM_FILTER_SHARPNESS                  "filter-sharpness"
 870
 871 /**
 872  * Pixel format that you want to capture. If you set MM_PIXEL_FORMAT_ENCODED,
 873  * the result will be encoded by image codec specified in #MMCAM_IMAGE_ENCODER.
 874  * If not, the result will be raw data.
 875  *
 876  * @see         MMPixelFormatType (in mm_types.h)
 877  */
 878 #define MMCAM_CAPTURE_FORMAT                    "capture-format"
 879
 880 /**
 881  * Width of the image that you want to capture
 882  */
 883 #define MMCAM_CAPTURE_WIDTH                     "capture-width"
 884
 885 /**
 886  * Height of the image that you want to capture
 887
 888  */
 889 #define MMCAM_CAPTURE_HEIGHT                    "capture-height"
 890
 891 /**
 892  * Total count of capturing. If you set this, it will caputre multiple time.
 893  */
 894 #define MMCAM_CAPTURE_COUNT                     "capture-count"
 895
 896 /**
 897  * Interval between each capturing on Multishot.
 898  */
 899 #define MMCAM_CAPTURE_INTERVAL                  "capture-interval"
 900
 901 /**
 902  * Set this when you want to stop multishot immediately.
 903  */
 904 #define MMCAM_CAPTURE_BREAK_CONTINUOUS_SHOT     "capture-break-cont-shot"
 905
 906 /**
 907  * Pointer of display buffer or ID of xwindow.
 908  */
 909 #define MMCAM_DISPLAY_HANDLE                    "display-handle"
 910
 911 /**
 912  * Device of display.
 913  * @see         MMDisplayDeviceType (in mm_types.h)
 914  */
 915 #define MMCAM_DISPLAY_DEVICE                    "display-device"
 916
 917 /**
 918  * Surface of display.
 919  * @see         MMDisplaySurfaceType (in mm_types.h)
 920  */
 921 #define MMCAM_DISPLAY_SURFACE                    "display-surface"
 922
 923 /**
 924  * X position of display rectangle.
 925  * This is only available when #MMCAM_DISPLAY_GEOMETRY_METHOD is MM_CAMCORDER_CUSTOM_ROI.
 926  * @see         MMCamcorderGeometryMethod
 927  */
 928 #define MMCAM_DISPLAY_RECT_X                    "display-rect-x"
 929
 930 /**
 931  * Y position of display rectangle
 932  * This is only available when #MMCAM_DISPLAY_GEOMETRY_METHOD is MM_CAMCORDER_CUSTOM_ROI.
 933  * @see         MMCamcorderGeometryMethod
 934  */
 935 #define MMCAM_DISPLAY_RECT_Y                    "display-rect-y"
 936
 937 /**
 938  * Width of display rectangle
 939  * This is only available when #MMCAM_DISPLAY_GEOMETRY_METHOD is MM_CAMCORDER_CUSTOM_ROI.
 940  * @see         MMCamcorderGeometryMethod
 941  */
 942 #define MMCAM_DISPLAY_RECT_WIDTH                "display-rect-width"
 943
 944 /**
 945  * Height of display rectangle
 946  * This is only available when #MMCAM_DISPLAY_GEOMETRY_METHOD is MM_CAMCORDER_CUSTOM_ROI.
 947  * @see         MMCamcorderGeometryMethod
 948  */
 949 #define MMCAM_DISPLAY_RECT_HEIGHT               "display-rect-height"
 950
 951 /**
 952  * X position of source rectangle. When you want to crop the source, you can set the area with this value.
 953  */
 954 #define MMCAM_DISPLAY_SOURCE_X                  "display-src-x"
 955
 956 /**
 957  * Y position of source rectangle. When you want to crop the source, you can set the area with this value.
 958  */
 959 #define MMCAM_DISPLAY_SOURCE_Y                  "display-src-y"
 960
 961 /**
 962  * Width of source rectangle. When you want to crop the source, you can set the area with this value.
 963  */
 964 #define MMCAM_DISPLAY_SOURCE_WIDTH              "display-src-width"
 965
 966 /**
 967  * Height of source rectangle. When you want to crop the source, you can set the area with this value.
 968  */
 969 #define MMCAM_DISPLAY_SOURCE_HEIGHT             "display-src-height"
 970
 971 /**
 972  * Rotation angle of display.
 973  * @see         MMDisplayRotationType (in mm_types.h)
 974  */
 975 #define MMCAM_DISPLAY_ROTATION                  "display-rotation"
 976
 977 /**
 978  * Visible of display.
 979  */
 980 #define MMCAM_DISPLAY_VISIBLE                   "display-visible"
 981
 982 /**
 983  * A scale of displayed image. Available value is like below.
 984  * @see         MMDisplayScaleType (in mm_types.h)
 985  */
 986 #define MMCAM_DISPLAY_SCALE                     "display-scale"
 987
 988 /**
 989  * A method that describes a form of geometry for display.
 990  * @see         MMCamcorderGeometryMethod
 991  */
 992 #define MMCAM_DISPLAY_GEOMETRY_METHOD           "display-geometry-method"
 993
 994 /**
 995  * Target filename. Only used in Audio/Video recording. This is not used for capturing.
 996  */
 997 #define MMCAM_TARGET_FILENAME                   "target-filename"
 998
 999 /**
1000  * Time limit(Second) of recording file. If the elapsed time of recording reaches this value,
1001  * camcorder will send 'MM_MESSAGE_CAMCORDER_TIME_LIMIT' message.
1002  */
1003 #define MMCAM_TARGET_TIME_LIMIT                 "target-time-limit"
1004
1005 /**
1006  * Enable to write tags. If this value is FALSE, none of tag information will be written to captured file.
1007  */
1008 #define MMCAM_TAG_ENABLE                        "tag-enable"
1009
1010 /**
1011  * Image description.
1012  */
1013 #define MMCAM_TAG_IMAGE_DESCRIPTION             "tag-image-description"
1014
1015 /**
1016  * Orientation of captured image
1017  * @see         MMCamcorderTagOrientation
1018  */
1019 #define MMCAM_TAG_ORIENTATION                   "tag-orientation"
1020
1021 /**
1022  * software name and version
1023  */
1024 #define MMCAM_TAG_SOFTWARE                      "tag-software"
1025
1026 /**
1027  * Enable to write tags related to GPS. If this value is TRUE, tags related GPS information will be written to captured file.
1028  */
1029 #define MMCAM_TAG_GPS_ENABLE                    "tag-gps-enable"
1030
1031 /**
1032  * Latitude of captured postion. GPS information.
1033  */
1034 #define MMCAM_TAG_LATITUDE                      "tag-latitude"
1035
1036 /**
1037  * Longitude of captured postion. GPS information.
1038  */
1039 #define MMCAM_TAG_LONGITUDE                     "tag-longitude"
1040
1041 /**
1042  * Altitude of captured postion. GPS information.
1043  */
1044 #define MMCAM_TAG_ALTITUDE                      "tag-altitude"
1045
1046 /**
1047  * Strobe control
1048  * @see         MMCamcorderStrobeControl
1049  */
1050 #define MMCAM_STROBE_CONTROL                    "strobe-control"
1051
1052 /**
1053  * Operation Mode of strobe
1054  * @see         MMCamcorderStrobeMode
1055  */
1056 #define MMCAM_STROBE_MODE                       "strobe-mode"
1057
1058 /**
1059  * Detection mode
1060  * @see         MMCamcorderDetectMode
1061  */
1062 #define MMCAM_DETECT_MODE                       "detect-mode"
1063
1064 /**
1065  * Total number of detected object
1066  */
1067 #define MMCAM_DETECT_NUMBER                     "detect-number"
1068
1069 /**
1070  * You can use this attribute to select one of detected objects.
1071  */
1072 #define MMCAM_DETECT_FOCUS_SELECT               "detect-focus-select"
1073
1074 /**
1075  * Recommend preview format for capture
1076  */
1077 #define MMCAM_RECOMMEND_PREVIEW_FORMAT_FOR_CAPTURE     "recommend-preview-format-for-capture"
1078
1079 /**
1080  * Recommend preview format for recording
1081  */
1082 #define MMCAM_RECOMMEND_PREVIEW_FORMAT_FOR_RECORDING   "recommend-preview-format-for-recording"
1083
1084 /**
1085  * Recommend rotation of display
1086  */
1087 #define MMCAM_RECOMMEND_DISPLAY_ROTATION               "recommend-display-rotation"
1088
1089 /**
1090  * Rotation angle of video input stream and display for video recording.
1091  */
1092 #define MMCAM_CAMCORDER_ROTATION                   "camcorder-rotation"
1093
1094 /*=======================================================================================
1095 | ENUM DEFINITIONS                                                                      |
1096 ========================================================================================*/
1097 /**
1098  * An enumeration for camcorder states.
1099  */
1100 typedef enum {
1101         MM_CAMCORDER_STATE_NONE,                /**< Camcorder is not created yet */
1102         MM_CAMCORDER_STATE_NULL,                /**< Camcorder is created, but not initialized yet */
1103         MM_CAMCORDER_STATE_READY,               /**< Camcorder is ready to capture */
1104         MM_CAMCORDER_STATE_PREPARE,             /**< Camcorder is prepared to capture (Preview) */
1105         MM_CAMCORDER_STATE_CAPTURING,           /**< Camcorder is now capturing still images */
1106         MM_CAMCORDER_STATE_RECORDING,           /**< Camcorder is now recording */
1107         MM_CAMCORDER_STATE_PAUSED,              /**< Camcorder is paused while recording */
1108         MM_CAMCORDER_STATE_NUM,                 /**< Number of camcorder states */
1109 } MMCamcorderStateType;
1110
1111 /**
1112  * An enumeration for camcorder mode.
1113  */
1114 typedef enum {
1115         MM_CAMCORDER_MODE_IMAGE = 0,            /**< Still image capture mode */
1116         MM_CAMCORDER_MODE_AUDIO,                /**< Audio recording mode */
1117         MM_CAMCORDER_MODE_VIDEO,                /**< Video recording mode */
1118 } MMCamcorderModeType;
1119
1120
1121 /**
1122  * An enumeration of Audio Format.
1123  */
1124 typedef enum
1125 {
1126         MM_CAMCORDER_AUDIO_FORMAT_PCM_U8 = 0,           /**< unsigned 8bit audio */
1127         MM_CAMCORDER_AUDIO_FORMAT_PCM_S16_LE = 2,       /**< signed 16bit audio. Little endian. */
1128 } MMCamcorderAudioFormat;
1129
1130
1131 /**
1132  * An enumeration for color tone. Color tone provides an impression of
1133  * seeing through a tinted glass.
1134  */
1135 enum MMCamcorderColorToneType {
1136         MM_CAMCORDER_COLOR_TONE_NONE = 0,               /**< None */
1137         MM_CAMCORDER_COLOR_TONE_MONO,                   /**< Mono */
1138         MM_CAMCORDER_COLOR_TONE_SEPIA,                  /**< Sepia */
1139         MM_CAMCORDER_COLOR_TONE_NEGATIVE,               /**< Negative */
1140         MM_CAMCORDER_COLOR_TONE_BLUE,                   /**< Blue */
1141         MM_CAMCORDER_COLOR_TONE_GREEN,                  /**< Green */
1142         MM_CAMCORDER_COLOR_TONE_AQUA,                   /**< Aqua */
1143         MM_CAMCORDER_COLOR_TONE_VIOLET,                 /**< Violet */
1144         MM_CAMCORDER_COLOR_TONE_ORANGE,                 /**< Orange */
1145         MM_CAMCORDER_COLOR_TONE_GRAY,                   /**< Gray */
1146         MM_CAMCORDER_COLOR_TONE_RED,                    /**< Red */
1147         MM_CAMCORDER_COLOR_TONE_ANTIQUE,                /**< Antique */
1148         MM_CAMCORDER_COLOR_TONE_WARM,                   /**< Warm */
1149         MM_CAMCORDER_COLOR_TONE_PINK,                   /**< Pink */
1150         MM_CAMCORDER_COLOR_TONE_YELLOW,                 /**< Yellow */
1151         MM_CAMCORDER_COLOR_TONE_PURPLE,                 /**< Purple */
1152         MM_CAMCORDER_COLOR_TONE_EMBOSS,                 /**< Emboss */
1153         MM_CAMCORDER_COLOR_TONE_OUTLINE,                /**< Outline */
1154
1155         MM_CAMCORDER_COLOR_TONE_SOLARIZATION_1,         /**< Solarization1 */
1156         MM_CAMCORDER_COLOR_TONE_SOLARIZATION_2,         /**< Solarization2 */
1157         MM_CAMCORDER_COLOR_TONE_SOLARIZATION_3,         /**< Solarization3 */
1158         MM_CAMCORDER_COLOR_TONE_SOLARIZATION_4,         /**< Solarization4 */
1159
1160         MM_CAMCORDER_COLOR_TONE_SKETCH_1,               /**< Sketch1 */
1161         MM_CAMCORDER_COLOR_TONE_SKETCH_2,               /**< Sketch2 */
1162         MM_CAMCORDER_COLOR_TONE_SKETCH_3,               /**< Sketch3 */
1163         MM_CAMCORDER_COLOR_TONE_SKETCH_4,               /**< Sketch4 */
1164 };
1165
1166
1167 /**
1168  * An enumeration for white balance. White Balance is the control that adjusts
1169  * the camcorder's color sensitivity to match the prevailing color of white
1170  * outdoor light, yellower indoor light, or (sometimes) greenish fluorescent
1171  * light. White balance may be set either automatically or manually. White balance
1172  * may be set "incorrectly" on purpose to achieve special effects.
1173  */
1174 enum MMCamcorderWhiteBalanceType {
1175         MM_CAMCORDER_WHITE_BALANCE_NONE = 0,            /**< None */
1176         MM_CAMCORDER_WHITE_BALANCE_AUTOMATIC,           /**< Automatic */
1177         MM_CAMCORDER_WHITE_BALANCE_DAYLIGHT,            /**< Daylight */
1178         MM_CAMCORDER_WHITE_BALANCE_CLOUDY,              /**< Cloudy */
1179         MM_CAMCORDER_WHITE_BALANCE_FLUOROSCENT,         /**< Fluorescent */
1180         MM_CAMCORDER_WHITE_BALANCE_INCANDESCENT,        /**< Incandescent */
1181         MM_CAMCORDER_WHITE_BALANCE_SHADE,               /**< Shade */
1182         MM_CAMCORDER_WHITE_BALANCE_HORIZON,             /**< Horizon */
1183         MM_CAMCORDER_WHITE_BALANCE_FLASH,               /**< Flash */
1184         MM_CAMCORDER_WHITE_BALANCE_CUSTOM,              /**< Custom */
1185
1186 };
1187
1188
1189 /**
1190  * An enumeration for scene mode. Scene mode gives the environment condition
1191  * for operating camcorder. The mode of operation can be in daylight, night and
1192  * backlight. It can be an automatic setting also.
1193  */
1194 enum MMCamcorderSceneModeType {
1195         MM_CAMCORDER_SCENE_MODE_NORMAL = 0,     /**< Normal */
1196         MM_CAMCORDER_SCENE_MODE_PORTRAIT,       /**< Portrait */
1197         MM_CAMCORDER_SCENE_MODE_LANDSCAPE,      /**< Landscape */
1198         MM_CAMCORDER_SCENE_MODE_SPORTS,         /**< Sports */
1199         MM_CAMCORDER_SCENE_MODE_PARTY_N_INDOOR, /**< Party & indoor */
1200         MM_CAMCORDER_SCENE_MODE_BEACH_N_INDOOR, /**< Beach & indoor */
1201         MM_CAMCORDER_SCENE_MODE_SUNSET,         /**< Sunset */
1202         MM_CAMCORDER_SCENE_MODE_DUSK_N_DAWN,    /**< Dusk & dawn */
1203         MM_CAMCORDER_SCENE_MODE_FALL_COLOR,     /**< Fall */
1204         MM_CAMCORDER_SCENE_MODE_NIGHT_SCENE,    /**< Night scene */
1205         MM_CAMCORDER_SCENE_MODE_FIREWORK,       /**< Firework */
1206         MM_CAMCORDER_SCENE_MODE_TEXT,           /**< Text */
1207         MM_CAMCORDER_SCENE_MODE_SHOW_WINDOW,    /**< Show window */
1208         MM_CAMCORDER_SCENE_MODE_CANDLE_LIGHT,   /**< Candle light */
1209         MM_CAMCORDER_SCENE_MODE_BACKLIGHT,      /**< Backlight */
1210 };
1211
1212
1213 /**
1214  * An enumeration for focusing .
1215  */
1216 enum MMCamcorderFocusMode {
1217         MM_CAMCORDER_FOCUS_MODE_NONE = 0,       /**< Focus mode is None */
1218         MM_CAMCORDER_FOCUS_MODE_PAN,            /**< Pan focus mode*/
1219         MM_CAMCORDER_FOCUS_MODE_AUTO,           /**< Autofocus mode*/
1220         MM_CAMCORDER_FOCUS_MODE_MANUAL,         /**< Manual focus mode*/
1221         MM_CAMCORDER_FOCUS_MODE_TOUCH_AUTO,     /**< Touch Autofocus mode*/
1222         MM_CAMCORDER_FOCUS_MODE_CONTINUOUS,     /**< Continuous Autofocus mode*/
1223 };
1224
1225
1226 /**
1227  * An enumeration for auto focus scan range (af scan range)
1228  */
1229 enum MMCamcorderAutoFocusType {
1230         MM_CAMCORDER_AUTO_FOCUS_NONE = 0,       /**< Scan autofocus is not set */
1231         MM_CAMCORDER_AUTO_FOCUS_NORMAL,         /**< Scan autofocus normally*/
1232         MM_CAMCORDER_AUTO_FOCUS_MACRO,          /**< Scan autofocus in macro mode(close distance)*/
1233         MM_CAMCORDER_AUTO_FOCUS_FULL,           /**< Scan autofocus in full mode(all range scan, limited by dev spec)*/
1234 };
1235
1236
1237 /**
1238  * An enumeration for focus state.
1239  * When 'MM_MESSAGE_CAMCORDER_FOCUS_CHANGED' is delievered through 'MMMessageCallback',
1240  * this enumeration will be set to 'code' of MMMessageParamType.
1241  */
1242 enum MMCamcorderFocusStateType {
1243         MM_CAMCORDER_FOCUS_STATE_RELEASED = 0,  /**< Focus released.*/
1244         MM_CAMCORDER_FOCUS_STATE_ONGOING,       /**< Focus in pregress*/
1245         MM_CAMCORDER_FOCUS_STATE_FOCUSED,       /**< Focus success*/
1246         MM_CAMCORDER_FOCUS_STATE_FAILED,        /**< Focus failed*/
1247 };
1248
1249
1250 /**
1251  * An enumeration for ISO.
1252  */
1253 enum MMCamcorderISOType {
1254         MM_CAMCORDER_ISO_AUTO = 0,              /**< ISO auto mode*/
1255         MM_CAMCORDER_ISO_50,                    /**< ISO 50*/
1256         MM_CAMCORDER_ISO_100,                   /**< ISO 100*/
1257         MM_CAMCORDER_ISO_200,                   /**< ISO 200*/
1258         MM_CAMCORDER_ISO_400,                   /**< ISO 400*/
1259         MM_CAMCORDER_ISO_800,                   /**< ISO 800*/
1260         MM_CAMCORDER_ISO_1600,                  /**< ISO 1600*/
1261         MM_CAMCORDER_ISO_3200,                  /**< ISO 3200*/
1262         MM_CAMCORDER_ISO_6400,                  /**< ISO 6400*/
1263         MM_CAMCORDER_ISO_12800,                 /**< ISO 12800*/
1264 };
1265
1266 /**
1267  * An enumeration for Automatic exposure.
1268  */
1269 enum MMCamcorderAutoExposureType {
1270         MM_CAMCORDER_AUTO_EXPOSURE_OFF = 0,     /**< AE off*/
1271         MM_CAMCORDER_AUTO_EXPOSURE_ALL,         /**< AE on, XXX mode*/
1272         MM_CAMCORDER_AUTO_EXPOSURE_CENTER_1,    /**< AE on, XXX mode*/
1273         MM_CAMCORDER_AUTO_EXPOSURE_CENTER_2,    /**< AE on, XXX mode*/
1274         MM_CAMCORDER_AUTO_EXPOSURE_CENTER_3,    /**< AE on, XXX mode*/
1275         MM_CAMCORDER_AUTO_EXPOSURE_SPOT_1,      /**< AE on, XXX mode*/
1276         MM_CAMCORDER_AUTO_EXPOSURE_SPOT_2,      /**< AE on, XXX mode*/
1277         MM_CAMCORDER_AUTO_EXPOSURE_CUSTOM_1,    /**< AE on, XXX mode*/
1278         MM_CAMCORDER_AUTO_EXPOSURE_CUSTOM_2,    /**< AE on, XXX mode*/
1279 };
1280
1281
1282 /**
1283  * An enumeration for WDR mode .
1284  */
1285 enum MMCamcorderWDRMode {
1286         MM_CAMCORDER_WDR_OFF = 0,               /**< WDR OFF*/
1287         MM_CAMCORDER_WDR_ON,                    /**< WDR ON*/
1288         MM_CAMCORDER_WDR_AUTO,                  /**< WDR AUTO*/
1289 };
1290
1291
1292 /**
1293  * An enumeration for Anti-handshake mode .
1294  */
1295 enum MMCamcorderAHSMode {
1296         MM_CAMCORDER_AHS_OFF = 0,               /**< AHS OFF*/
1297         MM_CAMCORDER_AHS_ON,                    /**< AHS ON*/
1298         MM_CAMCORDER_AHS_AUTO,                  /**< AHS AUTO*/
1299         MM_CAMCORDER_AHS_MOVIE,                 /**< AHS MOVIE*/
1300 };
1301
1302
1303 /**
1304  * Geometry method for camcorder display.
1305  */
1306 enum MMCamcorderGeometryMethod {
1307         MM_CAMCORDER_LETTER_BOX = 0,            /**< Letter box*/
1308         MM_CAMCORDER_ORIGIN_SIZE,               /**< Origin size*/
1309         MM_CAMCORDER_FULL,                      /**< full-screen*/
1310         MM_CAMCORDER_CROPPED_FULL,              /**< Cropped full-screen*/
1311         MM_CAMCORDER_CUSTOM_ROI,                /**< Explicitely described destination ROI*/
1312 };
1313
1314
1315 /**
1316  * An enumeration for orientation values of tag .
1317  */
1318 enum MMCamcorderTagOrientation {
1319         MM_CAMCORDER_TAG_ORT_NONE =0,           /**< No Orientation.*/
1320         MM_CAMCORDER_TAG_ORT_0R_VT_0C_VL,       /**< The 0th row is at the visual top of the image, and the 0th column is the visual left-hand side.*/
1321         MM_CAMCORDER_TAG_ORT_0R_VT_0C_VR,       /**< The 0th row is at the visual top of the image, and the 0th column is the visual right-hand side.*/
1322         MM_CAMCORDER_TAG_ORT_0R_VB_0C_VR,       /**< The 0th row is at the visual bottom of the image, and the 0th column is the visual right-hand side.*/
1323         MM_CAMCORDER_TAG_ORT_0R_VB_0C_VL,       /**< The 0th row is at the visual bottom of the image, and the 0th column is the visual left-hand side.*/
1324         MM_CAMCORDER_TAG_ORT_0R_VL_0C_VT,       /**< The 0th row is the visual left-hand side of the image, and the 0th column is the visual top.*/
1325         MM_CAMCORDER_TAG_ORT_0R_VR_0C_VT,       /**< The 0th row is the visual right-hand side of the image, and the 0th column is the visual top.*/
1326         MM_CAMCORDER_TAG_ORT_0R_VR_0C_VB,       /**< The 0th row is the visual right-hand side of the image, and the 0th column is the visual bottom.*/
1327         MM_CAMCORDER_TAG_ORT_0R_VL_0C_VB,       /**< The 0th row is the visual left-hand side of the image, and the 0th column is the visual bottom.*/
1328 };
1329
1330
1331 /**
1332  * An enumeration for Strobe mode.
1333  */
1334 enum MMCamcorderStrobeMode {
1335         MM_CAMCORDER_STROBE_MODE_OFF = 0,               /**< Always off */
1336         MM_CAMCORDER_STROBE_MODE_ON,                    /**< Always splashes */
1337         MM_CAMCORDER_STROBE_MODE_AUTO,                  /**< Depending on intensity of light, strobe starts to flash. */
1338         MM_CAMCORDER_STROBE_MODE_REDEYE_REDUCTION,      /**< Red eye reduction. Multiple flash before capturing. */
1339         MM_CAMCORDER_STROBE_MODE_SLOW_SYNC,             /**< Slow sync. A type of curtain synchronization. */
1340         MM_CAMCORDER_STROBE_MODE_FRONT_CURTAIN,         /**< Front curtain. A type of curtain synchronization. */
1341         MM_CAMCORDER_STROBE_MODE_REAR_CURTAIN,          /**< Rear curtain. A type of curtain synchronization. */
1342         MM_CAMCORDER_STROBE_MODE_PERMANENT,             /**< keep turned on until turning off */
1343 };
1344
1345
1346 /**
1347  * An enumeration for Strobe Control.
1348  */
1349 enum MMCamcorderStrobeControl {
1350         MM_CAMCORDER_STROBE_CONTROL_OFF = 0,    /**< turn off the flash light */
1351         MM_CAMCORDER_STROBE_CONTROL_ON,         /**< turn on the flash light */
1352         MM_CAMCORDER_STROBE_CONTROL_CHARGE,     /**< charge the flash light */
1353 };
1354
1355
1356 /**
1357  * An enumeration for Detection mode.
1358  */
1359 enum MMCamcorderDetectMode {
1360         MM_CAMCORDER_DETECT_MODE_OFF = 0,       /**< turn detection off */
1361         MM_CAMCORDER_DETECT_MODE_ON,            /**< turn detection on */
1362 };
1363
1364
1365 /**********************************
1366 *          Attribute info         *
1367 **********************************/
1368 /**
1369  * An enumeration for attribute values types.
1370  */
1371 typedef enum{
1372         MM_CAM_ATTRS_TYPE_INVALID = -1,         /**< Type is invalid */
1373         MM_CAM_ATTRS_TYPE_INT,                  /**< Integer type attribute */
1374         MM_CAM_ATTRS_TYPE_DOUBLE,               /**< Double type attribute */
1375         MM_CAM_ATTRS_TYPE_STRING,               /**< UTF-8 String type attribute */
1376         MM_CAM_ATTRS_TYPE_DATA,                 /**< Pointer type attribute */
1377         MM_CAM_ATTRS_TYPE_ARRAY,                /**< Array type attribute */
1378         MM_CAM_ATTRS_TYPE_RANGE,                /**< Range type attribute */
1379 }MMCamAttrsType;
1380
1381
1382 /**
1383  * An enumeration for attribute validation type.
1384  */
1385 typedef enum {
1386         MM_CAM_ATTRS_VALID_TYPE_INVALID = -1,   /**< Invalid validation type */
1387         MM_CAM_ATTRS_VALID_TYPE_NONE,           /**< Do not check validity */
1388         MM_CAM_ATTRS_VALID_TYPE_INT_ARRAY,      /**< validity checking type of integer array */
1389         MM_CAM_ATTRS_VALID_TYPE_INT_RANGE,      /**< validity checking type of integer range */
1390         MM_CAM_ATTRS_VALID_TYPE_DOUBLE_ARRAY,   /**< validity checking type of double array */
1391         MM_CAM_ATTRS_VALID_TYPE_DOUBLE_RANGE,   /**< validity checking type of double range */
1392 } MMCamAttrsValidType;
1393
1394
1395 /**
1396  * An enumeration for attribute access flag.
1397  */
1398 typedef enum {
1399         MM_CAM_ATTRS_FLAG_DISABLED = 0,         /**< None flag is set. This means the attribute is not allowed to use.  */
1400         MM_CAM_ATTRS_FLAG_READABLE = 1 << 0,    /**< Readable */
1401         MM_CAM_ATTRS_FLAG_WRITABLE = 1 << 1,    /**< Writable */
1402         MM_CAM_ATTRS_FLAG_MODIFIED = 1 << 2,    /**< Modified */
1403         MM_CAM_ATTRS_FLAG_RW = MM_CAM_ATTRS_FLAG_READABLE | MM_CAM_ATTRS_FLAG_WRITABLE, /**< Readable and Writable */
1404 } MMCamAttrsFlag;
1405
1406
1407 /*=======================================================================================
1408 | STRUCTURE DEFINITIONS                                                                 |
1409 ========================================================================================*/
1410 /**
1411  * A structure for attribute information
1412  */
1413 typedef struct {
1414         MMCamAttrsType type;
1415         MMCamAttrsFlag flag;
1416         MMCamAttrsValidType validity_type;
1417
1418         /**
1419          * A union that describes validity of the attribute.
1420          * Only when type is 'MM_CAM_ATTRS_TYPE_INT' or 'MM_CAM_ATTRS_TYPE_DOUBLE',
1421          * the attribute can have validity.
1422          */
1423         union {
1424                 /**
1425                  * Validity structure for integer array.
1426                  */
1427                  struct {
1428                         int *array;             /**< a pointer of array */
1429                         int count;              /**< size of array */
1430                         int def;                /**< default value. Real value not index of array */
1431                 } int_array;
1432
1433                 /**
1434                  * Validity structure for integer range.
1435                  */
1436                 struct {
1437                         int min;                /**< minimum range */
1438                         int max;                /**< maximum range */
1439                         int def;                /**< default value */
1440                 } int_range;
1441
1442                 /**
1443                  * Validity structure for double array.
1444                  */
1445                  struct {
1446                         double *array;          /**< a pointer of array */
1447                         int count;              /**< size of array */
1448                         double def;             /**< default value. Real value not index of array */
1449                 } double_array;
1450
1451                 /**
1452                  * Validity structure for double range.
1453                  */
1454                 struct {
1455                         double min;             /**< minimum range */
1456                         double max;             /**< maximum range */
1457                         double def;             /**< default value */
1458                 } double_range;
1459         };
1460 } MMCamAttrsInfo;
1461
1462
1463 /* General Structure */
1464 /**
1465  * Structure for capture data.
1466  */
1467 typedef struct {
1468         void *data;                     /**< pointer of captured image */
1469         unsigned int length;            /**< length of captured image (in byte)*/
1470         MMPixelFormatType format;       /**< image format */
1471         int width;                      /**< width of captured image */
1472         int height;                     /**< height of captured image */
1473         int encoder_type;               /**< encoder type */
1474 } MMCamcorderCaptureDataType;
1475
1476
1477 /**
1478  * Structure for video stream data.
1479  */
1480 typedef struct {
1481         void *data;                     /**< pointer of captured stream */
1482         unsigned int length;            /**< length of stream buffer (in byte)*/
1483         MMPixelFormatType format;       /**< image format */
1484         int width;                      /**< width of video buffer */
1485         int height;                     /**< height of video buffer */
1486         unsigned int timestamp;         /**< timestamp of stream buffer (msec)*/
1487 } MMCamcorderVideoStreamDataType;
1488
1489
1490 /**
1491  * Structure for audio stream data.
1492  */
1493 typedef struct {
1494         void *data;                             /**< pointer of captured stream */
1495         unsigned int length;                    /**< length of stream buffer (in byte)*/
1496         MMCamcorderAudioFormat format;          /**< audio format */
1497         int channel;                            /**< number of channel of the stream */
1498         unsigned int timestamp;                 /**< timestamp of stream buffer (msec)*/
1499         float volume_dB;                        /**< dB value of audio stream */
1500 } MMCamcorderAudioStreamDataType;
1501
1502
1503 /**
1504   * Prerequisite information for mm_camcorder_create()
1505   * The information to set prior to create.
1506   */
1507 typedef struct {
1508         enum MMVideoDeviceType videodev_type;   /**< Video device type */
1509         /* For future use */
1510         int reserved[4];                        /**< reserved fields */
1511 } MMCamPreset;
1512
1513
1514 /**
1515  * Report structure of recording file
1516  */
1517 typedef struct MMCamRecordingReport {
1518         char *recording_filename;               /**< File name of stored recording file. Please free after using. */
1519 }MMCamRecordingReport; /**< report structure definition of recording file */
1520
1521
1522 /*=======================================================================================
1523 | TYPE DEFINITIONS                                                                      |
1524 ========================================================================================*/
1525 /**
1526  *      Function definition for video stream callback.
1527  *  Be careful! In this function, you can't call functions that change the state of camcorder such as mm_camcorder_stop(),
1528  *  mm_camcorder_unrealize(), mm_camcorder_record(), mm_camcorder_commit(), and mm_camcorder_cancel(), etc.
1529  *  Please don't hang this function long. It may cause low performance of preview or occur timeout error from video source.
1530  *  Also, you're not allowed to call mm_camcorder_stop() even in other context, while you're hanging this function.
1531  *  I recommend to you releasing this function ASAP.
1532  *
1533  *      @param[in]      stream                  Reference pointer to video stream data
1534  *      @param[in]      user_param              User parameter which is received from user when callback function was set
1535  *      @return         This function returns true on success, or false on failure.
1536  *      @remarks                This function is issued in the context of gstreamer (video sink thread).
1537  */
1538 typedef gboolean (*mm_camcorder_video_stream_callback)(MMCamcorderVideoStreamDataType *stream, void *user_param);
1539
1540
1541 /**
1542  *      Function definition for audio stream callback.
1543  *  Be careful! In this function, you can't call functions that change the state of camcorder such as mm_camcorder_stop(),
1544  *  mm_camcorder_unrealize(), mm_camcorder_record(), mm_camcorder_commit(), and mm_camcorder_cancel(), etc.
1545  *  Please don't hang this function long. It may cause low performance of camcorder or occur timeout error from audio source.
1546  *  I recommend to you releasing this function ASAP.
1547  *
1548  *      @param[in]      stream                  Reference pointer to audio stream data
1549  *      @param[in]      user_param              User parameter which is received from user when callback function was set
1550  *      @return         This function returns true on success, or false on failure.
1551  *      @remarks
1552  */
1553 typedef gboolean (*mm_camcorder_audio_stream_callback)(MMCamcorderAudioStreamDataType *stream, void *user_param);
1554
1555
1556 /**
1557  *      Function definition for video capture callback.
1558  *  Like '#mm_camcorder_video_stream_callback', you can't call mm_camcorder_stop() while you are hanging this function.
1559  *
1560  *      @param[in]      frame                   Reference pointer to captured data
1561  *      @param[in]      thumbnail               Reference pointer to thumbnail data
1562  *      @param[in]      user_param              User parameter which is received from user when callback function was set
1563  *      @return         This function returns true on success, or false on failure.
1564  *      @remarks                This function is issued in the context of gstreamer (video src thread).
1565  */
1566 typedef gboolean (*mm_camcorder_video_capture_callback)(MMCamcorderCaptureDataType *frame, MMCamcorderCaptureDataType *thumbnail, void *user_param);
1567
1568
1569 /*=======================================================================================
1570 | GLOBAL FUNCTION PROTOTYPES                                                            |
1571 ========================================================================================*/
1572 /**
1573  *    mm_camcorder_create:\n
1574  *  Create camcorder object. This is the function that an user who wants to use mm_camcorder calls first.
1575  *  This function creates handle structure and initialize mutex, attributes, gstreamer.
1576  *  When this function success, it will return  a handle of newly created object.
1577  *  A user have to put the handle when he calls every function of mm_camcorder. \n
1578  *  Second argument of this function is the field to decribe pre-setting information of mm_camcorder such as which camera device it will use.
1579  *  Normally, MM_VIDEO_DEVICE_CAMERA0 is for Main camera(or Mega camera, Back camera),
1580  *  and MM_VIDEO_DEVICE_CAMERA1 is for VGA camera (or Front camera). If you want audio recording,
1581  *  please set MM_VIDEO_DEVICE_NONE. (No camera device is needed.)
1582  *
1583  *      @param[out]     camcorder       A handle of camcorder.
1584  *      @param[in]      info            Information for camera device. Depending on this information,
1585  *                                      camcorder opens different camera devices.
1586  *      @return         This function returns zero(MM_ERROR_NONE) on success, or negative value with error code.\n
1587  *                      Please refer 'mm_error.h' to know the exact meaning of the error.
1588  *      @see            mm_camcorder_destroy
1589  *      @pre            None
1590  *      @post           Next state of mm-camcorder will be MM_CAMCORDER_STATE_NULL
1591  *      @remarks        You can create multiple handles on a context at the same time. However,
1592  *                      camcorder cannot guarantee proper operation because of limitation of resources, such as
1593  *                      camera device, audio device, and display device.
1594  *      @par example
1595  *      @code
1596
1597 #include <mm_camcorder.h>
1598
1599 gboolean initialize_camcorder()
1600 {
1601         int err;
1602         MMCamPreset cam_info;
1603 #if 1
1604         cam_info.videodev_type = MM_VIDEO_DEVICE_CAMERA0;
1605 #else
1606         // when you want to record audio only, enable this.
1607         cam_info.videodev_type = MM_VIDEO_DEVICE_NONE;
1608 #endif
1609
1610         err = mm_camcorder_create(&hcam, &cam_info);
1611
1612         if (err != MM_ERROR_NONE) {
1613                 printf("Fail to call mm_camcorder_create = %x\n", err);
1614                 return FALSE;
1615         }
1616
1617         return TRUE;
1618 }
1619
1620  *      @endcode
1621  */
1622 int mm_camcorder_create(MMHandleType *camcorder, MMCamPreset *info);
1623
1624
1625 /**
1626  *    mm_camcorder_destroy:\n
1627  *  Destroy camcorder object. Release handle and all of the resources that were created in mm_camcorder_create().\n
1628  *  This is the finalizing function of mm_camcorder. If this function is not called or fails to call, the handle isn't released fully.
1629  *  This function releases attributes, mutexes, sessions, and handle itself. This function also removes all of remaining messages.
1630  *  So if your application should wait a certain message of mm_camcorder, please wait to call this function till getting the message.
1631  *
1632  *
1633  *      @param[in]      camcorder       A handle of camcorder.
1634  *      @return         This function returns zero(MM_ERROR_NONE) on success, or negative value with error code.\n
1635  *                      Please refer 'mm_error.h' to know the exact meaning of the error.
1636  *      @see            mm_camcorder_create
1637  *      @pre            Previous state of mm-camcorder should be MM_CAMCORDER_STATE_NULL
1638  *      @post           Because the handle is not valid, you can't check the state.
1639  *      @remarks        None
1640  *      @par example
1641  *      @code
1642
1643 #include <mm_camcorder.h>
1644
1645 gboolean destroy_camcorder()
1646 {
1647         int err;
1648
1649         //Destroy camcorder handle
1650         err = mm_camcorder_destroy(hcam);
1651         if (err < 0) {
1652                 printf("Fail to call mm_camcorder_destroy  = %x\n", err);
1653                 return FALSE;
1654         }
1655
1656         return TRUE;
1657 }
1658
1659  *      @endcode
1660  */
1661 int mm_camcorder_destroy(MMHandleType camcorder);
1662
1663
1664 /**
1665  *    mm_camcorder_realize:\n
1666  *  Allocate resources for camcorder and initialize it.
1667  *  This also creates streamer pipeline. So you have to set attributes that are pivotal to create
1668  *  the pipeline before calling this function. This function also takes a roll to manage confliction
1669  *  between different applications which use camcorder. For example, if you try to use camcorder when
1670  *  other application that is more important such as call application, this function will return
1671  *  'MM_ERROR_POLICY_BLOCKED'. On the contrary, if your application that uses camcorder starts to launch
1672  *  while another application that uses speaker and has lower priority, your application will kick
1673  *  another application.
1674  *
1675  *      @param[in]      camcorder       A handle of camcorder.
1676  *      @return         This function returns zero(MM_ERROR_NONE) on success, or negative value with error code.\n
1677  *                      Please refer 'mm_error.h' to know the exact meaning of the error.
1678  *      @see            mm_camcorder_unrealize
1679  *      @pre            Previous state of mm-camcorder should be MM_CAMCORDER_STATE_NULL
1680  *      @post           Next state of mm-camcorder will be MM_CAMCORDER_STATE_READY
1681  *      @remarks        None
1682  *      @par example
1683  *      @code
1684
1685 #include <mm_camcorder.h>
1686
1687 //For image capturing
1688 gboolean initialize_image_capture()
1689 {
1690         int err;
1691         MMCamPreset cam_info;
1692         char *err_attr_name = NULL;
1693         void * hdisplay = NULL;
1694         int hsize = 0;
1695
1696         //Set video device as 'camera0' (main camera device)
1697         cam_info.videodev_type = MM_VIDEO_DEVICE_CAMERA0;
1698
1699         err = mm_camcorder_create(&hcam, &cam_info);
1700
1701         if (err != MM_ERROR_NONE) {
1702                 printf("Fail to call mm_camcorder_create = %x\n", err);
1703                 return FALSE;
1704         }
1705
1706         mm_camcorder_set_message_callback(hcam,(MMMessageCallback)msg_callback, (void*)hcam);
1707         mm_camcorder_set_video_capture_callback(hcam,(mm_camcorder_video_capture_callback)camcordertest_video_capture_cb, (void*)hcam);
1708
1709         hdisplay = &ad.xid;             //xid of xwindow. This value can be different depending on your environment.
1710         hsize = sizeof(ad.xid);         //size of xid structure.
1711
1712         // camcorder attribute setting
1713         err = mm_camcorder_set_attributes((MMHandleType)hcam, &err_attr_name,
1714                                           MMCAM_MODE, MM_CAMCORDER_MODE_IMAGE,
1715                                           MMCAM_IMAGE_ENCODER, MM_IMAGE_CODEC_JPEG,
1716                                           MMCAM_CAMERA_WIDTH, 640,
1717                                           MMCAM_CAMERA_HEIGHT, 480,
1718                                           MMCAM_CAMERA_FORMAT, MM_PIXEL_FORMAT_YUYV,
1719                                           MMCAM_CAMERA_FPS, 30,
1720                                           MMCAM_DISPLAY_ROTATION, MM_DISPLAY_ROTATION_270,
1721                                           MMCAM_DISPLAY_HANDLE, (void*) hdisplay,          hsize,
1722                                           MMCAM_CAPTURE_FORMAT, MM_PIXEL_FORMAT_ENCODED,
1723                                           MMCAM_CAPTURE_WIDTH, 640,
1724                                           MMCAM_CAPTURE_HEIGHT, 480,
1725                                           NULL);
1726
1727         if (err < 0) {
1728                 printf("Set attrs fail. (%s:%x)\n", err_attr_name, err);
1729                 if (err_attr_name) {
1730                         free(err_attr_name);
1731                         err_attr_name = NULL;
1732                         return FALSE;
1733                 }
1734         }
1735
1736         err =  mm_camcorder_realize(hcam);
1737         if (err < 0) {
1738                 printf("Fail to call mm_camcorder_realize  = %x\n", err);
1739                 return FALSE;
1740         }
1741
1742         return TRUE;
1743 }
1744
1745 //For A/V capturing
1746 gboolean initialize_video_capture()
1747 {
1748         int err;
1749         MMCamPreset cam_info;
1750         char *err_attr_name = NULL;
1751         void * hdisplay = NULL;
1752         int hsize = 0;
1753
1754         //Set video device as 'camera0' (main camera device)
1755         cam_info.videodev_type = MM_VIDEO_DEVICE_CAMERA0;
1756
1757         err = mm_camcorder_create(&hcam, &cam_info);
1758
1759         if (err != MM_ERROR_NONE) {
1760                 printf("Fail to call mm_camcorder_create = %x\n", err);
1761                 return FALSE;
1762         }
1763
1764         mm_camcorder_set_message_callback(hcam,(MMMessageCallback)msg_callback, hcam);
1765
1766         hdisplay = &ad.xid;             //xid of xwindow. This value can be different depending on your environment.
1767         hsize = sizeof(ad.xid);         //size of xid structure.
1768
1769         // camcorder attribute setting
1770         err = mm_camcorder_set_attributes((MMHandleType)hcam, &err_attr_name,
1771                                           MMCAM_MODE, MM_CAMCORDER_MODE_VIDEO,
1772                                           MMCAM_AUDIO_DEVICE, MM_AUDIO_DEVICE_MIC,
1773                                           MMCAM_AUDIO_ENCODER, MM_AUDIO_CODEC_AAC,
1774                                           MMCAM_VIDEO_ENCODER, MM_VIDEO_CODEC_MPEG4,
1775                                           MMCAM_FILE_FORMAT, MM_FILE_FORMAT_3GP,
1776                                           MMCAM_CAMERA_WIDTH, 1280,
1777                                           MMCAM_CAMERA_HEIGHT, 720,
1778                                           MMCAM_CAMERA_FORMAT, MM_PIXEL_FORMAT_NV12,
1779                                           MMCAM_CAMERA_FPS, 30,
1780                                           MMCAM_AUDIO_SAMPLERATE, 44100,
1781                                           MMCAM_AUDIO_FORMAT, MM_CAMCORDER_AUDIO_FORMAT_PCM_S16_LE,
1782                                           MMCAM_AUDIO_CHANNEL, 2,
1783                                           MMCAM_DISPLAY_ROTATION, MM_DISPLAY_ROTATION_270,
1784                                           MMCAM_DISPLAY_HANDLE, (void*) hdisplay,               hsize,
1785                                           MMCAM_TARGET_FILENAME, TARGET_FILENAME, strlen(TARGET_FILENAME),
1786                                           NULL);
1787
1788         if (err < 0) {
1789                 printf("Set attrs fail. (%s:%x)\n", err_attr_name, err);
1790                 if (err_attr_name) {
1791                         free(err_attr_name);
1792                         err_attr_name = NULL;
1793                         return FALSE;
1794                 }
1795         }
1796
1797         err =  mm_camcorder_realize(hcam);
1798         if (err < 0) {
1799                 printf("Fail to call mm_camcorder_realize  = %x\n", err);
1800                 return FALSE;
1801         }
1802
1803         return TRUE;
1804 }
1805
1806 //For audio(only) capturing
1807 gboolean initialize_audio_capture()
1808 {
1809         int err;
1810         MMCamPreset cam_info;
1811         char *err_attr_name = NULL;
1812         void * hdisplay = NULL;
1813         int hsize = 0;
1814
1815         //Set no video device, because audio recording doesn't need video input.
1816         cam_info.videodev_type = MM_VIDEO_DEVICE_NONE;
1817
1818         err = mm_camcorder_create(&hcam, &cam_info);
1819
1820         if (err != MM_ERROR_NONE) {
1821                 printf("Fail to call mm_camcorder_create = %x\n", err);
1822                 return FALSE;
1823         }
1824
1825         mm_camcorder_set_message_callback(hcam,(MMMessageCallback)msg_callback, (void*)hcam);
1826
1827         hdisplay = &ad.xid;             //xid of xwindow. This value can be different depending on your environment.
1828         hsize = sizeof(ad.xid);         //size of xid structure.
1829
1830         // camcorder attribute setting
1831         err = mm_camcorder_set_attributes((MMHandleType)hcam, &err_attr_name,
1832                                           MMCAM_MODE, MM_CAMCORDER_MODE_AUDIO,
1833                                           MMCAM_AUDIO_DEVICE, MM_AUDIO_DEVICE_MIC,
1834                                           MMCAM_AUDIO_ENCODER, MM_AUDIO_CODEC_AAC,
1835                                           MMCAM_FILE_FORMAT, MM_FILE_FORMAT_3GP,
1836                                           MMCAM_AUDIO_SAMPLERATE, 44100,
1837                                           MMCAM_AUDIO_FORMAT, MM_CAMCORDER_AUDIO_FORMAT_PCM_S16_LE,
1838                                           MMCAM_AUDIO_CHANNEL, 2,
1839                                           MMCAM_TARGET_FILENAME, TARGET_FILENAME, strlen(TARGET_FILENAME),
1840                                           MMCAM_TARGET_TIME_LIMIT, 360000,
1841                                           NULL);
1842
1843         if (err < 0) {
1844                 printf("Set attrs fail. (%s:%x)\n", err_attr_name, err);
1845                 if (err_attr_name) {
1846                         free(err_attr_name);
1847                         err_attr_name = NULL;
1848                         return FALSE;
1849                 }
1850         }
1851
1852         err =  mm_camcorder_realize(hcam);
1853         if (err < 0) {
1854                 printf("Fail to call mm_camcorder_realize  = %x\n", err);
1855                 return FALSE;
1856         }
1857
1858         return TRUE;
1859 }
1860  *      @endcode
1861  */
1862 int mm_camcorder_realize(MMHandleType camcorder);
1863
1864
1865 /**
1866  *    mm_camcorder_unrealize:\n
1867  *  Uninitialize camcoder resources and free allocated memory.
1868  *  Most important resource that is released here is gstreamer pipeline of mm_camcorder.
1869  *  Because most of resources, such as camera device, video display device, and audio I/O device, are operating on the gstreamer pipeline,
1870  *  this function should be called to release its resources.
1871  *  Moreover, mm_camcorder is controlled by audio session manager. If an user doesn't call this function when he want to release mm_camcorder,
1872  *  other multimedia frameworks may face session problem. For more detail information, please refer mm_session module.
1873  *
1874  *      @param[in]      camcorder       A handle of camcorder.
1875  *      @return         This function returns zero(MM_ERROR_NONE) on success, or negative value with error code.\n
1876  *                      Please refer 'mm_error.h' to know the exact meaning of the error.
1877  *      @see            mm_camcorder_realize
1878  *      @pre            Previous state of mm-camcorder should be MM_CAMCORDER_STATE_READY
1879  *      @post           Next state of mm-camcorder will be MM_CAMCORDER_STATE_NULL
1880  *      @remarks        None
1881  *      @par example
1882  *      @code
1883
1884 #include <mm_camcorder.h>
1885
1886 gboolean unrealize_camcorder()
1887 {
1888         int err;
1889
1890         //Release all resources of camcorder handle
1891         err =  mm_camcorder_unrealize(hcam);
1892         if (err < 0) {
1893                 printf("Fail to call mm_camcorder_unrealize  = %x\n", err);
1894                 return FALSE;
1895         }
1896
1897         return TRUE;
1898 }
1899
1900  *      @endcode
1901  */
1902 int mm_camcorder_unrealize(MMHandleType camcorder);
1903
1904
1905 /**
1906  *      mm_camcorder_start:\n
1907  *   Start previewing. (Image/Video mode)
1908  *  'mm_camcorder_video_stream_callback' is activated after calling this function.
1909  *
1910  *      @param[in]      camcorder       A handle of camcorder.
1911  *      @return         This function returns zero(MM_ERROR_NONE) on success, or negative value with error code.\n
1912  *                      Please refer 'mm_error.h' to know the exact meaning of the error.
1913  *      @see            mm_camcorder_stop
1914  *      @pre            Previous state of mm-camcorder should be MM_CAMCORDER_STATE_READY
1915  *      @post           Next state of mm-camcorder will be MM_CAMCORDER_STATE_PREPARE
1916  *      @remarks        None
1917  *      @par example
1918  *      @code
1919
1920 #include <mm_camcorder.h>
1921
1922 //For image capturing
1923 gboolean initialize_image_capture()
1924 {
1925         int err;
1926         MMCamPreset cam_info;
1927         char *err_attr_name = NULL;
1928         void * hdisplay = NULL;
1929         int hsize = 0;
1930
1931         //Set video device as 'camera0' (main camera device)
1932         cam_info.videodev_type = MM_VIDEO_DEVICE_CAMERA0;
1933
1934         err = mm_camcorder_create(&hcam, &cam_info);
1935
1936         if (err != MM_ERROR_NONE) {
1937                         printf("Fail to call mm_camcorder_create = %x\n", err);
1938                         return FALSE;
1939         }
1940
1941         mm_camcorder_set_message_callback(hcam,(MMMessageCallback)msg_callback, (void*)hcam);
1942         mm_camcorder_set_video_capture_callback(hcam,(mm_camcorder_video_capture_callback)camcordertest_video_capture_cb, (void*)hcam);
1943
1944         hdisplay = &ad.xid;             //xid of xwindow. This value can be different depending on your environment.
1945         hsize = sizeof(ad.xid);         //size of xid structure.
1946
1947         // camcorder attribute setting
1948         err = mm_camcorder_set_attributes((MMHandleType)hcam, &err_attr_name,
1949                                           MMCAM_MODE, MM_CAMCORDER_MODE_IMAGE,
1950                                           MMCAM_IMAGE_ENCODER, MM_IMAGE_CODEC_JPEG,
1951                                           MMCAM_CAMERA_WIDTH, 640,
1952                                           MMCAM_CAMERA_HEIGHT, 480,
1953                                           MMCAM_CAMERA_FORMAT, MM_PIXEL_FORMAT_YUYV,
1954                                           MMCAM_CAMERA_FPS, 30,
1955                                           MMCAM_DISPLAY_ROTATION, MM_DISPLAY_ROTATION_270,
1956                                           MMCAM_DISPLAY_HANDLE, (void*) hdisplay,          hsize,
1957                                           MMCAM_CAPTURE_FORMAT, MM_PIXEL_FORMAT_ENCODED,
1958                                           MMCAM_CAPTURE_WIDTH, 640,
1959                                           MMCAM_CAPTURE_HEIGHT, 480,
1960                                           NULL);
1961
1962         if (err < 0) {
1963                 printf("Set attrs fail. (%s:%x)\n", err_attr_name, err);
1964                 if (err_attr_name) {
1965                         free(err_attr_name);
1966                         err_attr_name = NULL;
1967                         return FALSE;
1968                 }
1969         }
1970
1971         err =  mm_camcorder_realize(hcam);
1972         if (err < 0) {
1973                 printf("Fail to call mm_camcorder_realize  = %x\n", err);
1974                 return FALSE;
1975         }
1976
1977         // start camcorder
1978         err = mm_camcorder_start(hcam);
1979         if (err < 0) {
1980                 printf("Fail to call mm_camcorder_start  = %x\n", err);
1981                 return FALSE;
1982         }
1983
1984         return TRUE;
1985 }
1986
1987 //For A/V capturing
1988 gboolean initialize_video_capture()
1989 {
1990         int err;
1991         MMCamPreset cam_info;
1992         char *err_attr_name = NULL;
1993         void * hdisplay = NULL;
1994         int hsize = 0;
1995
1996         //Set video device as 'camera0' (main camera device)
1997         cam_info.videodev_type = MM_VIDEO_DEVICE_CAMERA0;
1998
1999         err = mm_camcorder_create(&hcam, &cam_info);
2000
2001         if (err != MM_ERROR_NONE) {
2002                         printf("Fail to call mm_camcorder_create = %x\n", err);
2003                         return FALSE;
2004         }
2005
2006         mm_camcorder_set_message_callback(hcam,(MMMessageCallback)msg_callback, hcam);
2007
2008         hdisplay = &ad.xid;             //xid of xwindow. This value can be different depending on your environment.
2009         hsize = sizeof(ad.xid);         //size of xid structure.
2010
2011         // camcorder attribute setting
2012         err = mm_camcorder_set_attributes((MMHandleType)hcam, &err_attr_name,
2013                                           MMCAM_MODE, MM_CAMCORDER_MODE_VIDEO,
2014                                           MMCAM_AUDIO_DEVICE, MM_AUDIO_DEVICE_MIC,
2015                                           MMCAM_AUDIO_ENCODER, MM_AUDIO_CODEC_AAC,
2016                                           MMCAM_VIDEO_ENCODER, MM_VIDEO_CODEC_MPEG4,
2017                                           MMCAM_FILE_FORMAT, MM_FILE_FORMAT_3GP,
2018                                           MMCAM_CAMERA_WIDTH, 1280,
2019                                           MMCAM_CAMERA_HEIGHT, 720,
2020                                           MMCAM_CAMERA_FORMAT, MM_PIXEL_FORMAT_NV12,
2021                                           MMCAM_CAMERA_FPS, 30,
2022                                           MMCAM_AUDIO_SAMPLERATE, 44100,
2023                                           MMCAM_AUDIO_FORMAT, MM_CAMCORDER_AUDIO_FORMAT_PCM_S16_LE,
2024                                           MMCAM_AUDIO_CHANNEL, 2,
2025                                           MMCAM_DISPLAY_ROTATION, MM_DISPLAY_ROTATION_270,
2026                                           MMCAM_DISPLAY_HANDLE, (void*) hdisplay,               hsize,
2027                                           MMCAM_TARGET_FILENAME, TARGET_FILENAME, strlen(TARGET_FILENAME),
2028                                           NULL);
2029
2030         if (err < 0) {
2031                 printf("Set attrs fail. (%s:%x)\n", err_attr_name, err);
2032                 if (err_attr_name) {
2033                         free(err_attr_name);
2034                         err_attr_name = NULL;
2035                         return FALSE;
2036                 }
2037         }
2038
2039         err =  mm_camcorder_realize(hcam);
2040         if (err < 0) {
2041                 printf("Fail to call mm_camcorder_realize  = %x\n", err);
2042                 return FALSE;
2043         }
2044
2045         // start camcorder
2046         err = mm_camcorder_start(hcam);
2047         if (err < 0) {
2048                 printf("Fail to call mm_camcorder_start  = %x\n", err);
2049                 return FALSE;
2050         }
2051
2052         return TRUE;
2053 }
2054
2055 //For audio(only) capturing
2056 gboolean initialize_audio_capture()
2057 {
2058         int err;
2059         MMCamPreset cam_info;
2060         char *err_attr_name = NULL;
2061         void * hdisplay = NULL;
2062         int hsize = 0;
2063
2064         //Set no video device, because audio recording doesn't need video input.
2065         cam_info.videodev_type = MM_VIDEO_DEVICE_NONE;
2066
2067         err = mm_camcorder_create(&hcam, &cam_info);
2068
2069         if (err != MM_ERROR_NONE) {
2070                 printf("Fail to call mm_camcorder_create = %x\n", err);
2071                 return FALSE;
2072         }
2073
2074         mm_camcorder_set_message_callback(hcam,(MMMessageCallback)msg_callback, (void*)hcam);
2075
2076         hdisplay = &ad.xid;             //xid of xwindow. This value can be different depending on your environment.
2077         hsize = sizeof(ad.xid);         //size of xid structure.
2078
2079         // camcorder attribute setting
2080         err = mm_camcorder_set_attributes((MMHandleType)hcam, &err_attr_name,
2081                                           MMCAM_MODE, MM_CAMCORDER_MODE_AUDIO,
2082                                           MMCAM_AUDIO_DEVICE, MM_AUDIO_DEVICE_MIC,
2083                                           MMCAM_AUDIO_ENCODER, MM_AUDIO_CODEC_AAC,
2084                                           MMCAM_FILE_FORMAT, MM_FILE_FORMAT_3GP,
2085                                           MMCAM_AUDIO_SAMPLERATE, 44100,
2086                                           MMCAM_AUDIO_FORMAT, MM_CAMCORDER_AUDIO_FORMAT_PCM_S16_LE,
2087                                           MMCAM_AUDIO_CHANNEL, 2,
2088                                           MMCAM_TARGET_FILENAME, TARGET_FILENAME, strlen(TARGET_FILENAME),
2089                                           MMCAM_TARGET_TIME_LIMIT, 360000,
2090                                           NULL);
2091
2092         if (err < 0) {
2093                 printf("Set attrs fail. (%s:%x)\n", err_attr_name, err);
2094                 if (err_attr_name) {
2095                         free(err_attr_name);
2096                         err_attr_name = NULL;
2097                         return FALSE;
2098                 }
2099         }
2100
2101         err =  mm_camcorder_realize(hcam);
2102         if (err < 0) {
2103                 printf("Fail to call mm_camcorder_realize  = %x\n", err);
2104                 return FALSE;
2105         }
2106
2107         // start camcorder
2108         err = mm_camcorder_start(hcam);
2109         if (err < 0) {
2110                 printf("Fail to call mm_camcorder_start  = %x\n", err);
2111                 return FALSE;
2112         }
2113
2114         return TRUE;
2115 }
2116  *      @endcode
2117  */
2118 int mm_camcorder_start(MMHandleType camcorder);
2119
2120
2121 /**
2122  *    mm_camcorder_stop:\n
2123  *  Stop previewing. (Image/Video mode)
2124  *  This function will change the status of pipeline. If an application doesn't return callbacks
2125  *  of camcorder, this function can be locked. For example, if your application still
2126  *  holds '#mm_camcorder_video_capture_callback' or '#mm_camcorder_video_stream_callback',
2127  *  this function could be hung. So users have to return every callback before calling this function.
2128  *
2129  *      @param[in]      camcorder       A handle of camcorder.
2130  *      @return         This function returns zero(MM_ERROR_NONE) on success, or negative value with error code.\n
2131  *                      Please refer 'mm_error.h' to know the exact meaning of the error.
2132  *      @see            mm_camcorder_start
2133  *      @pre            Previous state of mm-camcorder should be MM_CAMCORDER_STATE_PREPARE
2134  *      @post           Next state of mm-camcorder will be MM_CAMCORDER_STATE_READY
2135  *      @remarks        None
2136  *      @par example
2137  *      @code
2138
2139 #include <mm_camcorder.h>
2140
2141 gboolean stop_camcorder()
2142 {
2143         int err;
2144
2145         //Stop preview
2146         err =  mm_camcorder_stop(hcam);
2147         if (err < 0) {
2148                 printf("Fail to call mm_camcorder_stop  = %x\n", err);
2149                 return FALSE;
2150         }
2151
2152         return TRUE;
2153 }
2154
2155  *      @endcode
2156  */
2157 int mm_camcorder_stop(MMHandleType camcorder);
2158
2159
2160 /**
2161  *    mm_camcorder_capture_start:\n
2162  *  Start capturing of still images. (Image mode only)
2163  *  Captured image will be delievered through 'mm_camcorder_video_capture_callback'.
2164  *  So basically, the operation is working asynchronously. \n
2165  *  When a user call this function, MSL will stop to retrieving preview from camera device.
2166  *  Then set capture resolution, pixel format, and encoding type to camera driver. After resuming,
2167  *  camera can get still image.  A user will be notified by
2168  *  'MM_MESSAGE_CAMCORDER_CAPTURED' message when capturing succeed. When a user sets
2169  *  multishot (by setting multiple number to MMCAM_CAPTURE_COUNT), the message
2170  *  will be called multiple time. You can get the number of image from 'code' of
2171  *  'MMMessageParamType'.
2172  *
2173  *      @param[in]      camcorder       A handle of camcorder.
2174  *      @return         This function returns zero(MM_ERROR_NONE) on success, or negative value with error code.\n
2175  *                      Please refer 'mm_error.h' to know the exact meaning of the error.
2176  *      @see            mm_camcorder_capture_stop
2177  *      @pre            Previous state of mm-camcorder should be MM_CAMCORDER_STATE_PREPARE
2178  *      @post           Next state of mm-camcorder will be MM_CAMCORDER_STATE_CAPTURING
2179  *      @remarks        To call this function, preview should be started successfully.\n
2180  *                      This function is a pair of mm_camcorder_capture_stop().
2181  *                      So user should call mm_camcorder_capture_stop() after getting captured image.
2182  *      @par example
2183  *      @code
2184
2185 #include <mm_camcorder.h>
2186
2187 gboolean capturing_picture()
2188 {
2189         int err;
2190
2191         err =  mm_camcorder_capture_start(hcam);
2192         if (err < 0)
2193         {
2194                 printf("Fail to call mm_camcorder_capture_start  = %x\n", err);
2195                 return FALSE;
2196         }
2197
2198         //mm_camcorder_capture_stop should be called after getting
2199         //MM_MESSAGE_CAMCORDER_CAPTURED message.
2200
2201         return TRUE;
2202 }
2203
2204
2205  *      @endcode
2206  */
2207 int mm_camcorder_capture_start(MMHandleType camcorder);
2208
2209
2210 /**
2211  *    mm_camcorder_capture_stop:\n
2212  *  Stop capturing of still images. (Image mode only)
2213  *  This function notifies the end of capturing and launch preview again.
2214  *  Just as mm_camcorder_capture_start(), this funciton stops still image stream and set preview information such as
2215  *  resolution, pixel format, and framerate to camera driver. Then it command to start preview.
2216  *  If you don't call this, preview will not be displayed even though capturing was finished.
2217  *
2218  *      @param[in]      camcorder       A handle of camcorder.
2219  *      @return         This function returns zero(MM_ERROR_NONE) on success, or negative value with error code.\n
2220  *                      Please refer 'mm_error.h' to know the exact meaning of the error.
2221  *      @see            mm_camcorder_capture_start
2222  *      @pre            Previous state of mm-camcorder should be MM_CAMCORDER_STATE_CAPTURING
2223  *      @post           Next state of mm-camcorder will be MM_CAMCORDER_STATE_PREPARE
2224  *      @remarks        To call this function, a user has to call mm_camcorder_capture_start() first.\n
2225  *                      This is not a function to stop multishot in the middle of operation. For that,
2226  *                      please use '#MMCAM_CAPTURE_BREAK_CONTINUOUS_SHOT' instead.
2227  *      @par example
2228  *      @code
2229
2230 #include <mm_camcorder.h>
2231
2232 gboolean capturing_picture_stop()
2233 {
2234         int err;
2235
2236         err =  mm_camcorder_capture_stop(hcam);
2237         if (err < 0) {
2238                 printf("Fail to call mm_camcorder_capture_stop  = %x\n", err);
2239                 return FALSE;
2240         }
2241
2242         //After calling upper function, preview will start.
2243
2244         return TRUE;
2245 }
2246
2247  *      @endcode
2248  */
2249 int mm_camcorder_capture_stop(MMHandleType camcorder);
2250
2251
2252 /**
2253  *    mm_camcorder_record:\n
2254  *  Start recording. (Audio/Video mode only)
2255  *  Camcorder starts to write a file when you call this function. You can specify the name of file
2256  *  using '#MMCAM_TARGET_FILENAME'. Beware, if you fail to call mm_camcorder_commit() or mm_camcorder_cancel(),
2257  *  the recorded file is still on the storage.
2258  *
2259  *      @param[in]      camcorder       A handle of camcorder.
2260  *      @return         This function returns zero(MM_ERROR_NONE) on success, or negative value with error code.\n
2261  *                      Please refer 'mm_error.h' to know the exact meaning of the error.
2262  *      @see            mm_camcorder_pause
2263  *      @pre            Previous state of mm-camcorder should be MM_CAMCORDER_STATE_PREPARE
2264  *      @post           Next state of mm-camcorder will be MM_CAMCORDER_STATE_RECORDING
2265  *      @remarks        None
2266  *      @par example
2267  *      @code
2268
2269 #include <mm_camcorder.h>
2270
2271 gboolean record_and_cancel_video_file()
2272 {
2273         int err;
2274
2275         // Start recording
2276         err =  mm_camcorder_record(hcam);
2277         if (err < 0) {
2278                 printf("Fail to call mm_camcorder_record  = %x\n", err);
2279                 return FALSE;
2280         }
2281
2282         return TRUE;
2283 }
2284
2285  *      @endcode
2286  */
2287 int mm_camcorder_record(MMHandleType camcorder);
2288
2289
2290 /**
2291  *    mm_camcorder_pause:\n
2292  *  Pause A/V recording or Audio recording. (Audio/Video mode only)
2293  *  On video recording, you can see preview while on pausing. So mm_camcorder cuts video stream path to encoder and keep the flow to preview.
2294  *  If you call mm_camcorder_commit() while on pausing, the recorded file only has Audio and Video stream which were generated before pause().
2295  *
2296  *      @param[in]      camcorder       A handle of camcorder.
2297  *      @return         This function returns zero(MM_ERROR_NONE) on success, or negative value with error code.\n
2298  *                      Please refer 'mm_error.h' to know the exact meaning of the error.
2299  *      @see            mm_camcorder_record
2300  *      @pre            Previous state of mm-camcorder should be MM_CAMCORDER_STATE_RECORDING
2301  *      @post           Next state of mm-camcorder will be MM_CAMCORDER_STATE_PAUSED
2302  *      @remarks        Even though this function is for pausing recording, small amount of buffers could be recorded after pause().
2303  *                      Because the buffers which are existed in the queue were created before pause(), the buffers should be recorded.
2304  *      @par example
2305  *      @code
2306
2307 #include <mm_camcorder.h>
2308
2309 gboolean record_pause_and_resume_recording()
2310 {
2311         int err;
2312
2313         // Start recording
2314         err =  mm_camcorder_record(hcam);
2315         if (err < 0) {
2316                 printf("Fail to call mm_camcorder_record  = %x\n", err);
2317                 return FALSE;
2318         }
2319
2320         // Wait while recording...
2321
2322         // Pause
2323         err =  mm_camcorder_pause(hcam);
2324         if (err < 0) {
2325                 printf("Fail to call mm_camcorder_pause  = %x\n", err);
2326                 return FALSE;
2327         }
2328
2329         // Pausing...
2330
2331         // Resume
2332         err =  mm_camcorder_record(hcam);
2333         if (err < 0) {
2334                 printf("Fail to call mm_camcorder_record  = %x\n", err);
2335                 return FALSE;
2336         }
2337
2338         return TRUE;
2339 }
2340
2341
2342  *      @endcode
2343  */
2344 int mm_camcorder_pause(MMHandleType camcorder);
2345
2346
2347 /**
2348  *    mm_camcorder_commit:\n
2349  *  Stop recording and save results.  (Audio/Video mode only)\n
2350  *  After starting recording, encoded data frame will be stored in the location specified in MMCAM_TARGET_FILENAME.
2351  *  Some encoder or muxer require a certain type of finalizing such as adding some information to header.
2352  *  This function takes that roll. So if you don't call this function after recording, the result file may not be playable.\n
2353  *  After committing successfully, camcorder resumes displaying preview (video recording case).
2354  *  Because this is the function for saving the recording result, the operation is available
2355  *  only when the mode of camcorder is MM_CAMCORDER_MODE_AUDIO or MM_CAMCORDER_MODE_VIDEO.
2356  *
2357  *      @param[in]      camcorder       A handle of camcorder.
2358  *      @return         This function returns zero(MM_ERROR_NONE) on success, or negative value with error code.\n
2359  *                      Please refer 'mm_error.h' to know the exact meaning of the error.
2360  *      @see            mm_camcorder_cancel
2361  *      @pre            Previous state of mm-camcorder should be MM_CAMCORDER_STATE_RECORDING
2362  *      @post           Next state of mm-camcorder will be MM_CAMCORDER_STATE_PREPARE
2363  *      @remarks        This function can take a few second when recording time is long.
2364  *                      and if there are only quite few input buffer from video src or audio src,
2365  *                      committing could be failed.
2366  *      @par example
2367  *      @code
2368
2369 #include <mm_camcorder.h>
2370
2371 gboolean record_and_save_video_file()
2372 {
2373         int err;
2374
2375         // Start recording
2376         err =  mm_camcorder_record(hcam);
2377         if (err < 0) {
2378                 printf("Fail to call mm_camcorder_record  = %x\n", err);
2379                 return FALSE;
2380         }
2381
2382         // Wait while recording for test...
2383         // In normal case, mm_camcorder_record() and mm_camcorder_commit() aren't called in the same function.
2384
2385         // Save file
2386         err =  mm_camcorder_commit(hcam);
2387         if (err < 0) {
2388                 printf("Fail to call mm_camcorder_commit  = %x\n", err);
2389                 return FALSE;
2390         }
2391
2392         return TRUE;
2393 }
2394
2395  *      @endcode
2396  */
2397 int mm_camcorder_commit(MMHandleType camcorder);
2398
2399
2400 /**
2401  *      mm_camcorder_cancel:\n
2402  *    Stop recording and discard the result. (Audio/Video mode only)
2403  *      When a user want to finish recording without saving the result file, this function can be used.
2404  *      Like mm_camcorder_commit(), this function also stops recording, release related resources(like codec) ,and goes back to preview status.
2405  *      However, instead of saving file, this function unlinks(delete) the result.\n
2406  *      Because this is the function for canceling recording, the operation is available
2407  *      only when mode is MM_CAMCORDER_MODE_AUDIO or MM_CAMCORDER_MODE_VIDEO.
2408  *
2409  *      @param[in]      camcorder       A handle of camcorder.
2410  *      @return         This function returns zero(MM_ERROR_NONE) on success, or negative value with error code.\n
2411  *                      Please refer 'mm_error.h' to know the exact meaning of the error.
2412  *      @see            mm_camcorder_commit
2413  *      @pre            Previous state of mm-camcorder should be MM_CAMCORDER_STATE_RECORDING
2414  *      @post           Next state of mm-camcorder will be MM_CAMCORDER_STATE_PREPARE
2415  *      @remarks        None
2416  *      @par example
2417  *      @code
2418
2419 #include <mm_camcorder.h>
2420
2421 gboolean record_and_cancel_video_file()
2422 {
2423         int err;
2424
2425         // Start recording
2426         err =  mm_camcorder_record(hcam);
2427         if (err < 0) {
2428                 printf("Fail to call mm_camcorder_record  = %x\n", err);
2429                 return FALSE;
2430         }
2431
2432         // Wait while recording...
2433
2434         // Cancel recording
2435         err =  mm_camcorder_cancel(hcam);
2436         if (err < 0) {
2437                 printf("Fail to call mm_camcorder_cancel  = %x\n", err);
2438                 return FALSE;
2439         }
2440
2441         return TRUE;
2442 }
2443
2444  *      @endcode
2445  */
2446 int mm_camcorder_cancel(MMHandleType camcorder);
2447
2448
2449 /**
2450  *    mm_camcorder_set_message_callback:\n
2451  *  Set callback for receiving messages from camcorder. Through this callback function, camcorder
2452  *  sends various message including status changes, asynchronous error, capturing, and limitations.
2453  *  One thing you have to know is that message callback is working on the main loop of application.
2454  *  So until releasing the main loop, message callback will not be called.
2455  *
2456  *      @param[in]      camcorder       A handle of camcorder.
2457  *      @param[in]      callback        Function pointer of callback function. Please refer 'MMMessageCallback'.
2458  *      @param[in]      user_data       User parameter for passing to callback function.
2459  *      @return         This function returns zero(MM_ERROR_NONE) on success, or negative value with error code.\n
2460  *                      Please refer 'mm_error.h' to know the exact meaning of the error.
2461  *      @see            MMMessageCallback
2462  *      @pre            None
2463  *      @post           None
2464  *      @remarks        registered 'callback' is called on main loop of the application. So until the main loop is released, 'callback' will not be called.
2465  *      @par example
2466  *      @code
2467
2468 #include <mm_camcorder.h>
2469
2470 gboolean setting_msg_callback()
2471 {
2472         //set callback
2473         mm_camcorder_set_message_callback(hcam,(MMMessageCallback)msg_callback, (void*)hcam);
2474
2475         return TRUE;
2476 }
2477
2478
2479  *      @endcode
2480  */
2481 int mm_camcorder_set_message_callback(MMHandleType camcorder, MMMessageCallback callback, void *user_data);
2482
2483
2484 /**
2485  *    mm_camcorder_set_video_stream_callback:\n
2486  *  Set callback for user defined video stream callback function.
2487  *  Users can retrieve video frame using registered callback.
2488  *  The callback function holds the same buffer that will be drawed on the display device.
2489  *  So if an user change the buffer, it will be displayed on the device.
2490  *
2491  *      @param[in]      camcorder       A handle of camcorder.
2492  *      @param[in]      callback        Function pointer of callback function.
2493  *      @param[in]      user_data       User parameter for passing to callback function.
2494  *      @return         This function returns zero(MM_ERROR_NONE) on success, or negative value with error code.\n
2495  *                      Please refer 'mm_error.h' to know the exact meaning of the error.
2496  *      @see            mm_camcorder_video_stream_callback
2497  *      @pre            None
2498  *      @post           None
2499  *      @remarks        registered 'callback' is called on internal thread of camcorder. Regardless of the status of main loop, this function will be called.
2500  *      @par example
2501  *      @code
2502
2503 #include <mm_camcorder.h>
2504
2505 gboolean setting_video_stream_callback()
2506 {
2507         //set callback
2508         mm_camcorder_set_video_stream_callback(hcam, (mm_camcorder_video_stream_callback)camcordertest_video_stream_cb, (void*)hcam);
2509
2510         return TRUE;
2511 }
2512  *      @endcode
2513  */
2514 int mm_camcorder_set_video_stream_callback(MMHandleType camcorder, mm_camcorder_video_stream_callback callback, void *user_data);
2515
2516
2517 /**
2518  *    mm_camcorder_set_video_capture_callback:\n
2519  *  Set callback for user defined video capture callback function.  (Image mode only)
2520  *  mm_camcorder deliever captured image through the callback.\n
2521  *  Normally, this function provides main captured image and thumnail image. But depending on the environment,
2522  *  thumnail would not be available. Information related with main captured image and thumnail image is also included
2523  *  in the argument of the callback function.
2524  *  For more detail information of callback, please refer 'mm_camcorder_video_capture_callback'.
2525  *
2526  *      @param[in]      camcorder       A handle of camcorder.
2527  *      @param[in]      callback        Function pointer of callback function.
2528  *      @param[in]      user_data       User parameter for passing to callback function.
2529  *      @return         This function returns zero(MM_ERROR_NONE) on success, or negative value with error code.\n
2530  *                      Please refer 'mm_error.h' to know the exact meaning of the error.
2531  *      @see            mm_camcorder_video_capture_callback
2532  *      @pre            None
2533  *      @post           None
2534  *      @remarks        registered 'callback' is called on internal thread of camcorder. Regardless of the status of main loop, this function will be called.
2535  *      @par example
2536  *      @code
2537
2538 #include <mm_camcorder.h>
2539
2540 gboolean setting_capture_callback()
2541 {
2542         //set callback
2543         mm_camcorder_set_video_capture_callback(hcam,(mm_camcorder_video_capture_callback)camcordertest_video_capture_cb, (void*)hcam);
2544
2545         return TRUE;
2546 }
2547  *      @endcode
2548  */
2549 int mm_camcorder_set_video_capture_callback(MMHandleType camcorder, mm_camcorder_video_capture_callback callback, void *user_data);
2550
2551
2552 /**
2553  *    mm_camcorder_set_audio_stream_callback:\n
2554  *  Set callback for user defined audio stream callback function.
2555  *  Users can retrieve audio data using registered callback.
2556  *  The callback function holds the same buffer that will be recorded.
2557  *  So if an user change the buffer, the result file will has the buffer.
2558  *
2559  *      @param[in]      camcorder       A handle of camcorder.
2560  *      @param[in]      callback        Function pointer of callback function.
2561  *      @param[in]      user_data       User parameter for passing to callback function.
2562  *      @return         This function returns zero(MM_ERROR_NONE) on success, or negative value with error code.\n
2563  *                      Please refer 'mm_error.h' to know the exact meaning of the error.
2564  *      @see            mm_camcorder_audio_stream_callback
2565  *      @pre            None
2566  *      @post           None
2567  *      @remarks        registered 'callback' is called on internal thread of camcorder. Regardless of the status of main loop, this function will be called.
2568  *      @par example
2569  *      @code
2570
2571 #include <mm_camcorder.h>
2572
2573 gboolean setting_audio_stream_callback()
2574 {
2575         //set callback
2576         mm_camcorder_set_audio_stream_callback(hcam, (mm_camcorder_audio_stream_callback)camcordertest_audio_stream_cb, (void*)hcam);
2577
2578         return TRUE;
2579 }
2580  *      @endcode
2581  */
2582 int mm_camcorder_set_audio_stream_callback(MMHandleType camcorder, mm_camcorder_audio_stream_callback callback, void *user_data);
2583
2584
2585 /**
2586  *    mm_camcorder_get_state:\n
2587  *  Get the current state of camcorder.
2588  *  mm_camcorder is working on the base of its state. An user should check the state of mm_camcorder before calling its functions.
2589  *  If the handle is avaiable, user can retrieve the value.
2590  *
2591  *      @param[in]      camcorder       A handle of camcorder.
2592  *      @param[out]     state           On return, it contains current state of camcorder.
2593  *      @return         This function returns zero(MM_ERROR_NONE) on success, or negative value with error code.\n
2594  *                      Please refer 'mm_error.h' to know the exact meaning of the error.
2595  *      @see            MMCamcorderStateType
2596  *      @pre            None
2597  *      @post           None
2598  *      @remarks        None
2599  *      @par example
2600  *      @code
2601
2602 #include <mm_camcorder.h>
2603
2604 gboolean get_state_of_camcorder()
2605 {
2606         MMCamcorderStateType state;
2607
2608         //Get state of camcorder
2609         mm_camcorder_get_state(hcam, &state);
2610         printf("Current status is %d\n", state);
2611
2612         return TRUE;
2613 }
2614
2615  *      @endcode
2616  */
2617 int mm_camcorder_get_state(MMHandleType camcorder, MMCamcorderStateType *state);
2618
2619
2620 /**
2621  *    mm_camcorder_get_attributes:\n
2622  *  Get attributes of camcorder with given attribute names. This function can get multiple attributes
2623  *  simultaneously. If one of attribute fails, this function will stop at the point.
2624  *  'err_attr_name' let you know the name of the attribute.
2625  *
2626  *      @param[in]      camcorder       Specifies the camcorder  handle.
2627  *      @param[out]     err_attr_name   Specifies the name of attributes that made an error. If the function doesn't make an error, this will be null. @n
2628  *                                      Free this variable after using.
2629  *      @param[in]      attribute_name  attribute name that user want to get.
2630  *      @return         This function returns zero(MM_ERROR_NONE) on success, or negative value with error code.\n
2631  *                      Please refer 'mm_error.h' to know the exact meaning of the error.
2632  *      @pre            None
2633  *      @post           None
2634  *      @remarks        You can retrieve multiple attributes at the same time.  @n
2635  *                      This function must finish with 'NULL' argument.  @n
2636  *                      ex) mm_camcorder_get_attributes(....... , NULL);
2637  *      @see            mm_camcorder_set_attributes
2638  *      @par example
2639  *      @code
2640
2641 #include <mm_camcorder.h>
2642
2643 gboolean getting_attribute()
2644 {
2645         int err;
2646         MMCamPreset cam_info;
2647         char *err_attr_name = NULL;
2648         void * hdisplay = NULL;
2649         int hsize = 0;
2650
2651         hdisplay = &ad.xid;             //xid of xwindow. This value can be different depending on your environment.
2652         hsize = sizeof(ad.xid);         //size of xid structure.
2653
2654         // camcorder attribute setting
2655         err = mm_camcorder_get_attributes(hcamcorder, NULL,     //The second is the argument for debugging. But you can skip this.
2656                                           MMCAM_MODE,  &mode,   //You have to input a pointer instead of variable itself.
2657                                           NULL);                //mm_camcorder_set_attributes() should be finished with a NULL argument.
2658
2659         return TRUE;
2660 }
2661
2662  *      @endcode
2663  */
2664 int mm_camcorder_get_attributes(MMHandleType camcorder,  char **err_attr_name, const char *attribute_name, ...) G_GNUC_NULL_TERMINATED;
2665
2666
2667
2668 /**
2669  *    mm_camcorder_set_attributes:\n
2670  *  Set attributes of camcorder with given attribute names. This function can set multiple attributes
2671  *  simultaneously. If one of attribute fails, this function will stop at the point.
2672  *  'err_attr_name' let you know the name of the attribute.
2673  *
2674  *      @param[in]      camcorder       Specifies the camcorder  handle.
2675  *      @param[out]     err_attr_name   Specifies the name of attributes that made an error. If the function doesn't make an error, this will be null. @n
2676  *                                      Free this variable after using.
2677  *      @param[in]      attribute_name  attribute name that user want to set.
2678  *      @return         This function returns zero(MM_ERROR_NONE) on success, or negative value with error code.\n
2679  *                      Please refer 'mm_error.h' to know the exact meaning of the error.
2680  *      @pre            None
2681  *      @post           None
2682  *      @remarks        You can put multiple attributes to camcorder at the same time.  @n
2683  *                      This function must finish with 'NULL' argument.  @n
2684  *                      ex) mm_camcorder_set_attributes(....... , NULL);
2685  *      @see            mm_camcorder_get_attributes
2686  *      @par example
2687  *      @code
2688
2689 #include <mm_camcorder.h>
2690
2691 gboolean setting_attribute()
2692 {
2693         int err;
2694         MMCamPreset cam_info;
2695         char *err_attr_name = NULL;
2696         void * hdisplay = NULL;
2697         int hsize = 0;
2698
2699         hdisplay = &ad.xid;             //xid of xwindow. This value can be different depending on your environment.
2700         hsize = sizeof(ad.xid);         //size of xid structure.
2701
2702         // camcorder attribute setting
2703         err = mm_camcorder_set_attributes((MMHandleType)hcam, &err_attr_name,           //The second is the argument for debugging.
2704                                           MMCAM_MODE, MM_CAMCORDER_MODE_IMAGE,
2705                                           MMCAM_IMAGE_ENCODER, MM_IMAGE_CODEC_JPEG,
2706                                           MMCAM_CAMERA_WIDTH, 640,
2707                                           MMCAM_CAMERA_HEIGHT, 480,
2708                                           MMCAM_CAMERA_FORMAT, MM_PIXEL_FORMAT_YUYV,
2709                                           MMCAM_CAMERA_FPS, 30,
2710                                           MMCAM_DISPLAY_ROTATION, MM_DISPLAY_ROTATION_270,
2711                                           MMCAM_DISPLAY_HANDLE, (void*) hdisplay,          hsize,               //Beware some types require 'size' value, too. (STRING, DATA type attributes)
2712                                           MMCAM_CAPTURE_FORMAT, MM_PIXEL_FORMAT_ENCODED,
2713                                           MMCAM_CAPTURE_WIDTH, 640,
2714                                           MMCAM_CAPTURE_HEIGHT, 480,
2715                                           NULL);                //mm_camcorder_set_attributes() should be finished with a NULL argument.
2716
2717         if (err < 0) {
2718                 printf("Set attrs fail. (%s:%x)\n", err_attr_name, err);                //When the function failed, 'err_attr_name' has the name of attr that made the error.
2719                 if (err_attr_name) {
2720                         free(err_attr_name);                    //Please free 'err_attr_name', after using the argument.
2721                         err_attr_name = NULL;
2722                         return FALSE;
2723                 }
2724         }
2725
2726         return TRUE;
2727 }
2728  *      @endcode
2729  */
2730 int mm_camcorder_set_attributes(MMHandleType camcorder,  char **err_attr_name, const char *attribute_name, ...) G_GNUC_NULL_TERMINATED;
2731
2732
2733 /**
2734  *    mm_camcorder_get_attribute_info:\n
2735  *  Get detail information of the attribute. To manager attributes, an user may want to know the exact character of the attribute,
2736  *  such as type, flag, and validity. This is the function to provide such information.
2737  *  Depending on the 'validity_type', validity union would be different. To know about the type of union, please refer 'MMCamAttrsInfo'.
2738  *
2739  *      @param[in]      camcorder       Specifies the camcorder  handle.
2740  *      @param[in]      attribute_name  attribute name that user want to get information.
2741  *      @param[out]     info            a structure that holds information related with the attribute.
2742  *      @return         This function returns zero(MM_ERROR_NONE) on success, or negative value with error code.\n
2743  *                      Please refer 'mm_error.h' to know the exact meaning of the error.
2744  *      @pre            None
2745  *      @post           None
2746  *      @remarks        If the function succeeds, 'info' holds detail information about the attribute, such as type,
2747  *                      flag, validity_type, validity_values, and default values.
2748  *      @see            mm_camcorder_get_attributes, mm_camcorder_set_attributes
2749  *      @par example
2750  *      @code
2751
2752 #include <mm_camcorder.h>
2753
2754 gboolean getting_info_from_attribute()
2755 {
2756         MMCamAttrsInfo info;
2757         int err;
2758
2759         err = mm_camcorder_get_attribute_info(handle, MMCAM_CAPTURE_HEIGHT, &info);
2760         if (err < 0) {
2761                 printf("Fail to call mm_camcorder_get_attribute_info()");
2762                 return FALSE;
2763         }
2764
2765         //Now 'info' has many information about 'MMCAM_CAPTURE_HEIGHT'
2766
2767         return TRUE;
2768 }
2769  *      @endcode
2770  */
2771 int mm_camcorder_get_attribute_info(MMHandleType camcorder, const char *attribute_name, MMCamAttrsInfo *info);
2772
2773
2774 /**
2775  *    mm_camcorder_init_focusing:\n
2776  *  Initialize focusing. \n
2777  *  This function stops focusing action and adjust the camera lens to initial position.
2778  *  Some camera applciation requires to initialize its lens position after releasing half shutter. In that case,
2779  *  this should be a good choice. Comparing with mm_camcorder_stop_focusing, this function not only stops focusing,
2780  *  but also initialize the lens. Preview image might be out-focused after calling this function.
2781  *      @param[in]      camcorder  A handle of camcorder.
2782  *      @return         This function returns zero(MM_ERROR_NONE) on success, or negative value with error code.\n
2783  *                      Please refer 'mm_error.h' to know the exact meaning of the error.
2784  *      @pre            The status of camcorder should be MM_CAMCORDER_STATE_PREPARE, MM_CAMCORDER_STATE_RECORDING, or MM_CAMCORDER_STATE_PAUSED.
2785  *      @post           None
2786  *      @remarks        None
2787  *      @see            mm_camcorder_start_focusing, mm_camcorder_stop_focusing
2788  *      @par example
2789  *      @code
2790
2791 #include <mm_camcorder.h>
2792
2793 gboolean start_autofocus()
2794 {
2795         int err;
2796         char * err_attr_name = NULL;
2797
2798         // Set focus mode to 'AUTO' and scan range to 'AF Normal'.
2799         //You just need to set these values one time. After that, just call mm_camcorder_start_focusing().
2800         err = mm_camcorder_set_attributes((MMHandleType)hcam, &err_attr_name,
2801                                           MMCAM_CAMERA_FOCUS_MODE, MM_CAMCORDER_FOCUS_MODE_AUTO,
2802                                           MMCAM_CAMERA_AF_SCAN_RANGE, MM_CAMCORDER_AUTO_FOCUS_NORMAL,
2803                                           NULL);
2804
2805         if (err < 0) {
2806                 printf("Set attrs fail. (%s:%x)\n", err_attr_name, err);
2807                 if (err_attr_name) {
2808                         free(err_attr_name);
2809                         err_attr_name = NULL;
2810                         return FALSE;
2811                 }
2812         }
2813
2814         mm_camcorder_init_focusing(hcam);
2815         mm_camcorder_start_focusing(hcam);
2816         printf("Waiting for adjusting focus\n");
2817
2818         // Waiting for 'MM_MESSAGE_CAMCORDER_FOCUS_CHANGED'
2819
2820         return TRUE;
2821 }
2822
2823  *      @endcode
2824  */
2825 int mm_camcorder_init_focusing(MMHandleType camcorder);
2826
2827
2828 /**
2829  *    mm_camcorder_start_focusing:\n
2830  *  Start focusing. \n
2831  *  This function command to start focusing opeartion. Because focusing operation depends on mechanic or electric module,
2832  *  it may take small amount of time. (For ex, 500ms ~ 3sec). \n
2833  *  This function works asynchronously. When an user call this function,  it will return immediately.
2834  *  However, focusing operation will continue until it gets results.
2835  *  After finishing operation, you can get 'MM_MESSAGE_CAMCORDER_FOCUS_CHANGED' message.
2836  *  'param.code' of the message structure describes the fucusing was success or not.
2837  *
2838  *      @param[in]      camcorder       A handle of camcorder.
2839  *      @return         This function returns zero(MM_ERROR_NONE) on success, or negative value with error code.\n
2840  *                      Please refer 'mm_error.h' to know the exact meaning of the error.
2841  *      @pre            None
2842  *      @post           None
2843  *      @remarks        None
2844  *      @see            mm_camcorder_init_focusing, mm_camcorder_stop_focusing
2845  *      @par example
2846  *      @code
2847
2848 #include <mm_camcorder.h>
2849
2850 gboolean start_autofocus()
2851 {
2852         int err;
2853         char * err_attr_name = NULL;
2854
2855         // Set focus mode to 'AUTO' and scan range to 'AF Normal'.
2856         //You just need to set these values one time. After that, just call mm_camcorder_start_focusing().
2857         err = mm_camcorder_set_attributes((MMHandleType)hcam, &err_attr_name,
2858                                           MMCAM_CAMERA_FOCUS_MODE, MM_CAMCORDER_FOCUS_MODE_AUTO,
2859                                           MMCAM_CAMERA_AF_SCAN_RANGE, MM_CAMCORDER_AUTO_FOCUS_NORMAL,
2860                                           NULL);
2861
2862         if (err < 0) {
2863                 printf("Set attrs fail. (%s:%x)\n", err_attr_name, err);
2864                 if (err_attr_name) {
2865                         free(err_attr_name);
2866                         err_attr_name = NULL;
2867                         return FALSE;
2868                 }
2869         }
2870
2871         mm_camcorder_init_focusing(hcam);
2872         mm_camcorder_start_focusing(hcam);
2873         printf("Waiting for adjusting focus\n");
2874
2875         // Waiting for 'MM_MESSAGE_CAMCORDER_FOCUS_CHANGED'
2876
2877         return TRUE;
2878 }
2879
2880  *      @endcode
2881  */
2882 int mm_camcorder_start_focusing(MMHandleType camcorder);
2883
2884
2885 /**
2886  *    mm_camcorder_stop_focusing:\n
2887  *  Stop focusing. This function halts focusing operation.\n
2888  *  This is the function to stop focusing in the middle of the operation. So if focusing is already finished or not started yet,
2889  *  this function will do nothing.
2890  *
2891  *      @param[in]      camcorder       A handle of camcorder.
2892  *      @return         This function returns zero(MM_ERROR_NONE) on success, or negative value with error code.\n
2893  *                      Please refer 'mm_error.h' to know the exact meaning of the error.
2894  *      @see            mm_camcorder_init_focusing, mm_camcorder_start_focusing
2895  *      @pre            mm_camcorder_start_focusing() should be called before calling this function.
2896  *      @post           None
2897  *      @remarks        None
2898  *      @par example
2899  *      @code
2900
2901 #include <mm_camcorder.h>
2902
2903 gboolean stop_autofocus()
2904 {
2905         int err;
2906
2907         //Stop focusing
2908         mm_camcorder_stop_focusing(hcam);
2909
2910         return TRUE;
2911 }
2912
2913  *      @endcode
2914  */
2915 int mm_camcorder_stop_focusing(MMHandleType camcorder);
2916
2917 /**
2918         @}
2919  */
2920
2921 #ifdef __cplusplus
2922 }
2923 #endif
2924
2925 #endif /* __MM_CAMCORDER_H__ */